
s-link:     file format elf32-littlearm


Disassembly of section .init:

000103ac <_init>:
   103ac:	e1a0c00d 	mov	ip, sp
   103b0:	e92ddff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, ip, lr, pc}
   103b4:	e24cb004 	sub	fp, ip, #4
   103b8:	e91baff0 	ldmdb	fp, {r4, r5, r6, r7, r8, r9, sl, fp, sp, pc}

Disassembly of section .plt:

000103bc <putchar@plt-0x14>:
   103bc:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)
   103c0:	e59fe004 	ldr	lr, [pc, #4]	; 103cc <_init+0x20>
   103c4:	e08fe00e 	add	lr, pc, lr
   103c8:	e5bef008 	ldr	pc, [lr, #8]!
   103cc:	000120cc 	.word	0x000120cc

000103d0 <putchar@plt>:
   103d0:	e28fc600 	add	ip, pc, #0, 12
   103d4:	e28cca12 	add	ip, ip, #73728	; 0x12000
   103d8:	e5bcf0cc 	ldr	pc, [ip, #204]!	; 0xcc

000103dc <printf@plt>:
   103dc:	e28fc600 	add	ip, pc, #0, 12
   103e0:	e28cca12 	add	ip, ip, #73728	; 0x12000
   103e4:	e5bcf0c4 	ldr	pc, [ip, #196]!	; 0xc4

000103e8 <puts@plt>:
   103e8:	e28fc600 	add	ip, pc, #0, 12
   103ec:	e28cca12 	add	ip, ip, #73728	; 0x12000
   103f0:	e5bcf0bc 	ldr	pc, [ip, #188]!	; 0xbc

000103f4 <malloc@plt>:
   103f4:	e28fc600 	add	ip, pc, #0, 12
   103f8:	e28cca12 	add	ip, ip, #73728	; 0x12000
   103fc:	e5bcf0b4 	ldr	pc, [ip, #180]!	; 0xb4

00010400 <abort@plt>:
   10400:	e28fc600 	add	ip, pc, #0, 12
   10404:	e28cca12 	add	ip, ip, #73728	; 0x12000
   10408:	e5bcf0ac 	ldr	pc, [ip, #172]!	; 0xac

0001040c <__deregister_frame_info@plt>:
   1040c:	e28fc600 	add	ip, pc, #0, 12
   10410:	e28cca12 	add	ip, ip, #73728	; 0x12000
   10414:	e5bcf0a4 	ldr	pc, [ip, #164]!	; 0xa4

00010418 <__uClibc_main@plt>:
   10418:	e28fc600 	add	ip, pc, #0, 12
   1041c:	e28cca12 	add	ip, ip, #73728	; 0x12000
   10420:	e5bcf09c 	ldr	pc, [ip, #156]!	; 0x9c

00010424 <__register_frame_info@plt>:
   10424:	e28fc600 	add	ip, pc, #0, 12
   10428:	e28cca12 	add	ip, ip, #73728	; 0x12000
   1042c:	e5bcf094 	ldr	pc, [ip, #148]!	; 0x94

00010430 <free@plt>:
   10430:	e28fc600 	add	ip, pc, #0, 12
   10434:	e28cca12 	add	ip, ip, #73728	; 0x12000
   10438:	e5bcf08c 	ldr	pc, [ip, #140]!	; 0x8c

Disassembly of section .text:

0001043c <_start>:
   1043c:	e3a0b000 	.word	0xe3a0b000
   10440:	e3a0e000 	.word	0xe3a0e000
   10444:	e49d1004 	.word	0xe49d1004
   10448:	e1a0200d 	.word	0xe1a0200d
   1044c:	e52d2004 	.word	0xe52d2004
   10450:	e52d0004 	.word	0xe52d0004
   10454:	e59fc010 	.word	0xe59fc010
   10458:	e52dc004 	.word	0xe52dc004
   1045c:	e59f000c 	.word	0xe59f000c
   10460:	e59f300c 	.word	0xe59f300c
   10464:	eaffffeb 	.word	0xeaffffeb
   10468:	ebffffe4 	.word	0xebffffe4
   1046c:	00011e54 	.word	0x00011e54
   10470:	00011d34 	.word	0x00011d34
   10474:	000103ac 	.word	0x000103ac

00010478 <deregister_tm_clones>:
   10478:	e59f301c 	ldr	r3, [pc, #28]	; 1049c <deregister_tm_clones+0x24>
   1047c:	e59f001c 	ldr	r0, [pc, #28]	; 104a0 <deregister_tm_clones+0x28>
   10480:	e0603003 	rsb	r3, r0, r3
   10484:	e3530006 	cmp	r3, #6
   10488:	912fff1e 	bxls	lr
   1048c:	e59f3010 	ldr	r3, [pc, #16]	; 104a4 <deregister_tm_clones+0x2c>
   10490:	e3530000 	cmp	r3, #0
   10494:	012fff1e 	bxeq	lr
   10498:	e12fff13 	bx	r3
   1049c:	000224d3 	.word	0x000224d3
   104a0:	000224d0 	.word	0x000224d0
   104a4:	00000000 	.word	0x00000000

000104a8 <register_tm_clones>:
   104a8:	e59f1024 	ldr	r1, [pc, #36]	; 104d4 <register_tm_clones+0x2c>
   104ac:	e59f0024 	ldr	r0, [pc, #36]	; 104d8 <register_tm_clones+0x30>
   104b0:	e0601001 	rsb	r1, r0, r1
   104b4:	e1a01141 	asr	r1, r1, #2
   104b8:	e0811fa1 	add	r1, r1, r1, lsr #31
   104bc:	e1b010c1 	asrs	r1, r1, #1
   104c0:	012fff1e 	bxeq	lr
   104c4:	e59f3010 	ldr	r3, [pc, #16]	; 104dc <register_tm_clones+0x34>
   104c8:	e3530000 	cmp	r3, #0
   104cc:	012fff1e 	bxeq	lr
   104d0:	e12fff13 	bx	r3
   104d4:	000224d0 	.word	0x000224d0
   104d8:	000224d0 	.word	0x000224d0
   104dc:	00000000 	.word	0x00000000

000104e0 <__do_global_dtors_aux>:
   104e0:	e92d4010 	push	{r4, lr}
   104e4:	e59f402c 	ldr	r4, [pc, #44]	; 10518 <__do_global_dtors_aux+0x38>
   104e8:	e5d43000 	ldrb	r3, [r4]
   104ec:	e3530000 	cmp	r3, #0
   104f0:	18bd8010 	popne	{r4, pc}
   104f4:	ebffffdf 	bl	10478 <deregister_tm_clones>
   104f8:	e59f301c 	ldr	r3, [pc, #28]	; 1051c <__do_global_dtors_aux+0x3c>
   104fc:	e3530000 	cmp	r3, #0
   10500:	0a000001 	beq	1050c <__do_global_dtors_aux+0x2c>
   10504:	e59f0014 	ldr	r0, [pc, #20]	; 10520 <__do_global_dtors_aux+0x40>
   10508:	ebffffbf 	bl	1040c <__deregister_frame_info@plt>
   1050c:	e3a03001 	mov	r3, #1
   10510:	e5c43000 	strb	r3, [r4]
   10514:	e8bd8010 	pop	{r4, pc}
   10518:	000224d0 	.word	0x000224d0
   1051c:	00000000 	.word	0x00000000
   10520:	000123d0 	.word	0x000123d0

00010524 <frame_dummy>:
   10524:	e59f3040 	ldr	r3, [pc, #64]	; 1056c <frame_dummy+0x48>
   10528:	e92d4010 	push	{r4, lr}
   1052c:	e3530000 	cmp	r3, #0
   10530:	0a000002 	beq	10540 <frame_dummy+0x1c>
   10534:	e59f1034 	ldr	r1, [pc, #52]	; 10570 <frame_dummy+0x4c>
   10538:	e59f0034 	ldr	r0, [pc, #52]	; 10574 <frame_dummy+0x50>
   1053c:	ebffffb8 	bl	10424 <__register_frame_info@plt>
   10540:	e59f0030 	ldr	r0, [pc, #48]	; 10578 <frame_dummy+0x54>
   10544:	e5903000 	ldr	r3, [r0]
   10548:	e3530000 	cmp	r3, #0
   1054c:	1a000001 	bne	10558 <frame_dummy+0x34>
   10550:	e8bd4010 	pop	{r4, lr}
   10554:	eaffffd3 	b	104a8 <register_tm_clones>
   10558:	e59f301c 	ldr	r3, [pc, #28]	; 1057c <frame_dummy+0x58>
   1055c:	e3530000 	cmp	r3, #0
   10560:	0afffffa 	beq	10550 <frame_dummy+0x2c>
   10564:	e12fff33 	blx	r3
   10568:	eafffff8 	b	10550 <frame_dummy+0x2c>
   1056c:	00000000 	.word	0x00000000
   10570:	000224d4 	.word	0x000224d4
   10574:	000123d0 	.word	0x000123d0
   10578:	000223dc 	.word	0x000223dc
   1057c:	00000000 	.word	0x00000000

00010580 <display_debug>:
  int num;
  struct list * next;
};

void display_debug(struct list ** node)
{
   10580:	e92d4800 	push	{fp, lr}
   10584:	e28db004 	add	fp, sp, #4
   10588:	e24dd010 	sub	sp, sp, #16
   1058c:	e50b0010 	str	r0, [fp, #-16]
  struct list * src;
  int i;
 
  src = * node;
   10590:	e51b3010 	ldr	r3, [fp, #-16]
   10594:	e5933000 	ldr	r3, [r3]
   10598:	e50b3008 	str	r3, [fp, #-8]
  //for (i = 0, src; src != NULL; i++) {
  while (src) {
   1059c:	ea000008 	b	105c4 <display_debug+0x44>
    printf(" [%p:%d] ", src, src->num);
   105a0:	e51b3008 	ldr	r3, [fp, #-8]
   105a4:	e5933000 	ldr	r3, [r3]
   105a8:	e1a02003 	mov	r2, r3
   105ac:	e51b1008 	ldr	r1, [fp, #-8]
   105b0:	e59f0028 	ldr	r0, [pc, #40]	; 105e0 <display_debug+0x60>
   105b4:	ebffff88 	bl	103dc <printf@plt>
    src = src->next;
   105b8:	e51b3008 	ldr	r3, [fp, #-8]
   105bc:	e5933004 	ldr	r3, [r3, #4]
   105c0:	e50b3008 	str	r3, [fp, #-8]
  struct list * src;
  int i;
 
  src = * node;
  //for (i = 0, src; src != NULL; i++) {
  while (src) {
   105c4:	e51b3008 	ldr	r3, [fp, #-8]
   105c8:	e3530000 	cmp	r3, #0
   105cc:	1afffff3 	bne	105a0 <display_debug+0x20>
    printf(" [%p:%d] ", src, src->num);
    src = src->next;
    //printf(" %p ", src);
  }
  printf("\n");
   105d0:	e3a0000a 	mov	r0, #10
   105d4:	ebffff7d 	bl	103d0 <putchar@plt>
}
   105d8:	e24bd004 	sub	sp, fp, #4
   105dc:	e8bd8800 	pop	{fp, pc}
   105e0:	00011e64 	.word	0x00011e64

000105e4 <reverse_perfect_debug>:

struct list * reverse_perfect_debug(struct list * node)
{
   105e4:	e92d4800 	push	{fp, lr}
   105e8:	e28db004 	add	fp, sp, #4
   105ec:	e24dd020 	sub	sp, sp, #32
   105f0:	e50b0018 	str	r0, [fp, #-24]	; 0xffffffe8
  struct list * src, * des, * tmp;

  printf("%p:%p:%p:%p:%p\n", node, node->next, node->next->next, node->next->next->next, node->next->next->next->next);
   105f4:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   105f8:	e5931004 	ldr	r1, [r3, #4]
   105fc:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10600:	e5933004 	ldr	r3, [r3, #4]
   10604:	e5930004 	ldr	r0, [r3, #4]
   10608:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   1060c:	e5933004 	ldr	r3, [r3, #4]
   10610:	e5933004 	ldr	r3, [r3, #4]
   10614:	e5933004 	ldr	r3, [r3, #4]
   10618:	e51b2018 	ldr	r2, [fp, #-24]	; 0xffffffe8
   1061c:	e5922004 	ldr	r2, [r2, #4]
   10620:	e5922004 	ldr	r2, [r2, #4]
   10624:	e5922004 	ldr	r2, [r2, #4]
   10628:	e5922004 	ldr	r2, [r2, #4]
   1062c:	e58d2004 	str	r2, [sp, #4]
   10630:	e58d3000 	str	r3, [sp]
   10634:	e1a03000 	mov	r3, r0
   10638:	e1a02001 	mov	r2, r1
   1063c:	e51b1018 	ldr	r1, [fp, #-24]	; 0xffffffe8
   10640:	e59f00d0 	ldr	r0, [pc, #208]	; 10718 <reverse_perfect_debug+0x134>
   10644:	ebffff64 	bl	103dc <printf@plt>
  src = tmp = node;  // 指向第一个结点
   10648:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   1064c:	e50b300c 	str	r3, [fp, #-12]
   10650:	e51b300c 	ldr	r3, [fp, #-12]
   10654:	e50b3008 	str	r3, [fp, #-8]
  printf("src=node %p:%p \n", src, node);
   10658:	e51b2018 	ldr	r2, [fp, #-24]	; 0xffffffe8
   1065c:	e51b1008 	ldr	r1, [fp, #-8]
   10660:	e59f00b4 	ldr	r0, [pc, #180]	; 1071c <reverse_perfect_debug+0x138>
   10664:	ebffff5c 	bl	103dc <printf@plt>
  node = NULL; // 目前，链表node为空 (num, next 都为空)
   10668:	e3a03000 	mov	r3, #0
   1066c:	e50b3018 	str	r3, [fp, #-24]	; 0xffffffe8
  printf("node=NULL:%p \n\n", node);
   10670:	e51b1018 	ldr	r1, [fp, #-24]	; 0xffffffe8
   10674:	e59f00a4 	ldr	r0, [pc, #164]	; 10720 <reverse_perfect_debug+0x13c>
   10678:	ebffff57 	bl	103dc <printf@plt>
  while (src) {
   1067c:	ea00001b 	b	106f0 <reverse_perfect_debug+0x10c>
    des = src; // des 指向要翻转的结点
   10680:	e51b3008 	ldr	r3, [fp, #-8]
   10684:	e50b3010 	str	r3, [fp, #-16]
    printf("des=src %p:%p \n",des, src);
   10688:	e51b2008 	ldr	r2, [fp, #-8]
   1068c:	e51b1010 	ldr	r1, [fp, #-16]
   10690:	e59f008c 	ldr	r0, [pc, #140]	; 10724 <reverse_perfect_debug+0x140>
   10694:	ebffff50 	bl	103dc <printf@plt>
    src = src->next; // 指向下一个要翻转的结点
   10698:	e51b3008 	ldr	r3, [fp, #-8]
   1069c:	e5933004 	ldr	r3, [r3, #4]
   106a0:	e50b3008 	str	r3, [fp, #-8]
    printf("src=src->next %p:%p \n", src, src);
   106a4:	e51b2008 	ldr	r2, [fp, #-8]
   106a8:	e51b1008 	ldr	r1, [fp, #-8]
   106ac:	e59f0074 	ldr	r0, [pc, #116]	; 10728 <reverse_perfect_debug+0x144>
   106b0:	ebffff49 	bl	103dc <printf@plt>
    des->next = node; // 链接到翻转后的链表
   106b4:	e51b3010 	ldr	r3, [fp, #-16]
   106b8:	e51b2018 	ldr	r2, [fp, #-24]	; 0xffffffe8
   106bc:	e5832004 	str	r2, [r3, #4]
    printf("des->next=node %p:%p \n", des->next, node);
   106c0:	e51b3010 	ldr	r3, [fp, #-16]
   106c4:	e5933004 	ldr	r3, [r3, #4]
   106c8:	e51b2018 	ldr	r2, [fp, #-24]	; 0xffffffe8
   106cc:	e1a01003 	mov	r1, r3
   106d0:	e59f0054 	ldr	r0, [pc, #84]	; 1072c <reverse_perfect_debug+0x148>
   106d4:	ebffff40 	bl	103dc <printf@plt>
    node = des;  // 为链接下一个做准备
   106d8:	e51b3010 	ldr	r3, [fp, #-16]
   106dc:	e50b3018 	str	r3, [fp, #-24]	; 0xffffffe8
    printf("node=des %p:%p \n\n", node, des);
   106e0:	e51b2010 	ldr	r2, [fp, #-16]
   106e4:	e51b1018 	ldr	r1, [fp, #-24]	; 0xffffffe8
   106e8:	e59f0040 	ldr	r0, [pc, #64]	; 10730 <reverse_perfect_debug+0x14c>
   106ec:	ebffff3a 	bl	103dc <printf@plt>
  printf("%p:%p:%p:%p:%p\n", node, node->next, node->next->next, node->next->next->next, node->next->next->next->next);
  src = tmp = node;  // 指向第一个结点
  printf("src=node %p:%p \n", src, node);
  node = NULL; // 目前，链表node为空 (num, next 都为空)
  printf("node=NULL:%p \n\n", node);
  while (src) {
   106f0:	e51b3008 	ldr	r3, [fp, #-8]
   106f4:	e3530000 	cmp	r3, #0
   106f8:	1affffe0 	bne	10680 <reverse_perfect_debug+0x9c>
    des->next = node; // 链接到翻转后的链表
    printf("des->next=node %p:%p \n", des->next, node);
    node = des;  // 为链接下一个做准备
    printf("node=des %p:%p \n\n", node, des);
  }
  printf("return node : %p \n", node);
   106fc:	e51b1018 	ldr	r1, [fp, #-24]	; 0xffffffe8
   10700:	e59f002c 	ldr	r0, [pc, #44]	; 10734 <reverse_perfect_debug+0x150>
   10704:	ebffff34 	bl	103dc <printf@plt>

  return node;  // 返回翻转后的链表
   10708:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
}
   1070c:	e1a00003 	mov	r0, r3
   10710:	e24bd004 	sub	sp, fp, #4
   10714:	e8bd8800 	pop	{fp, pc}
   10718:	00011e70 	.word	0x00011e70
   1071c:	00011e80 	.word	0x00011e80
   10720:	00011e94 	.word	0x00011e94
   10724:	00011ea4 	.word	0x00011ea4
   10728:	00011eb4 	.word	0x00011eb4
   1072c:	00011ecc 	.word	0x00011ecc
   10730:	00011ee4 	.word	0x00011ee4
   10734:	00011ef8 	.word	0x00011ef8

00010738 <reverse_perfect_noreturn_debug>:

void  reverse_perfect_noreturn_debug(struct list ** node)
{
   10738:	e92d4800 	push	{fp, lr}
   1073c:	e28db004 	add	fp, sp, #4
   10740:	e24dd018 	sub	sp, sp, #24
   10744:	e50b0010 	str	r0, [fp, #-16]
  struct list * src, * des;

  printf("[%p:%p:%p]\n", node, * node, ** node);
   10748:	e51b3010 	ldr	r3, [fp, #-16]
   1074c:	e5931000 	ldr	r1, [r3]
   10750:	e51b3010 	ldr	r3, [fp, #-16]
   10754:	e5933000 	ldr	r3, [r3]
   10758:	e5932004 	ldr	r2, [r3, #4]
   1075c:	e58d2000 	str	r2, [sp]
   10760:	e5933000 	ldr	r3, [r3]
   10764:	e1a02001 	mov	r2, r1
   10768:	e51b1010 	ldr	r1, [fp, #-16]
   1076c:	e59f00f4 	ldr	r0, [pc, #244]	; 10868 <reverse_perfect_noreturn_debug+0x130>
   10770:	ebffff19 	bl	103dc <printf@plt>
  //printf("%p:%p:%p:%p:%p\n", node, node->next, node->next->next, node->next->next->next, node->next->next->next->next);
  src = * node;  // 指向第一个结点
   10774:	e51b3010 	ldr	r3, [fp, #-16]
   10778:	e5933000 	ldr	r3, [r3]
   1077c:	e50b3008 	str	r3, [fp, #-8]
  printf("src=node %p:%p \n", src, * node);
   10780:	e51b3010 	ldr	r3, [fp, #-16]
   10784:	e5933000 	ldr	r3, [r3]
   10788:	e1a02003 	mov	r2, r3
   1078c:	e51b1008 	ldr	r1, [fp, #-8]
   10790:	e59f00d4 	ldr	r0, [pc, #212]	; 1086c <reverse_perfect_noreturn_debug+0x134>
   10794:	ebffff10 	bl	103dc <printf@plt>
  * node = NULL; // 目前，链表node为空 (num, next 都为空)
   10798:	e51b3010 	ldr	r3, [fp, #-16]
   1079c:	e3a02000 	mov	r2, #0
   107a0:	e5832000 	str	r2, [r3]
  printf("node=NULL:%p \n\n", * node);
   107a4:	e51b3010 	ldr	r3, [fp, #-16]
   107a8:	e5933000 	ldr	r3, [r3]
   107ac:	e1a01003 	mov	r1, r3
   107b0:	e59f00b8 	ldr	r0, [pc, #184]	; 10870 <reverse_perfect_noreturn_debug+0x138>
   107b4:	ebffff08 	bl	103dc <printf@plt>
  while (src) {
   107b8:	ea000020 	b	10840 <reverse_perfect_noreturn_debug+0x108>
    des = src; // des 指向要翻转的结点
   107bc:	e51b3008 	ldr	r3, [fp, #-8]
   107c0:	e50b300c 	str	r3, [fp, #-12]
    printf("des=src %p:%p \n",des, src);
   107c4:	e51b2008 	ldr	r2, [fp, #-8]
   107c8:	e51b100c 	ldr	r1, [fp, #-12]
   107cc:	e59f00a0 	ldr	r0, [pc, #160]	; 10874 <reverse_perfect_noreturn_debug+0x13c>
   107d0:	ebffff01 	bl	103dc <printf@plt>
    src = src->next; // 指向下一个要翻转的结点
   107d4:	e51b3008 	ldr	r3, [fp, #-8]
   107d8:	e5933004 	ldr	r3, [r3, #4]
   107dc:	e50b3008 	str	r3, [fp, #-8]
    printf("src=src->next %p:%p \n", src, src);
   107e0:	e51b2008 	ldr	r2, [fp, #-8]
   107e4:	e51b1008 	ldr	r1, [fp, #-8]
   107e8:	e59f0088 	ldr	r0, [pc, #136]	; 10878 <reverse_perfect_noreturn_debug+0x140>
   107ec:	ebfffefa 	bl	103dc <printf@plt>
    des->next = * node; // 链接到翻转后的链表
   107f0:	e51b3010 	ldr	r3, [fp, #-16]
   107f4:	e5932000 	ldr	r2, [r3]
   107f8:	e51b300c 	ldr	r3, [fp, #-12]
   107fc:	e5832004 	str	r2, [r3, #4]
    printf("des->next=node %p:%p \n", des->next, * node);
   10800:	e51b300c 	ldr	r3, [fp, #-12]
   10804:	e5931004 	ldr	r1, [r3, #4]
   10808:	e51b3010 	ldr	r3, [fp, #-16]
   1080c:	e5933000 	ldr	r3, [r3]
   10810:	e1a02003 	mov	r2, r3
   10814:	e59f0060 	ldr	r0, [pc, #96]	; 1087c <reverse_perfect_noreturn_debug+0x144>
   10818:	ebfffeef 	bl	103dc <printf@plt>
    * node = des;  // 为链接下一个做准备
   1081c:	e51b3010 	ldr	r3, [fp, #-16]
   10820:	e51b200c 	ldr	r2, [fp, #-12]
   10824:	e5832000 	str	r2, [r3]
    printf("node=des %p:%p \n\n", * node, des);
   10828:	e51b3010 	ldr	r3, [fp, #-16]
   1082c:	e5933000 	ldr	r3, [r3]
   10830:	e51b200c 	ldr	r2, [fp, #-12]
   10834:	e1a01003 	mov	r1, r3
   10838:	e59f0040 	ldr	r0, [pc, #64]	; 10880 <reverse_perfect_noreturn_debug+0x148>
   1083c:	ebfffee6 	bl	103dc <printf@plt>
  //printf("%p:%p:%p:%p:%p\n", node, node->next, node->next->next, node->next->next->next, node->next->next->next->next);
  src = * node;  // 指向第一个结点
  printf("src=node %p:%p \n", src, * node);
  * node = NULL; // 目前，链表node为空 (num, next 都为空)
  printf("node=NULL:%p \n\n", * node);
  while (src) {
   10840:	e51b3008 	ldr	r3, [fp, #-8]
   10844:	e3530000 	cmp	r3, #0
   10848:	1affffdb 	bne	107bc <reverse_perfect_noreturn_debug+0x84>
    des->next = * node; // 链接到翻转后的链表
    printf("des->next=node %p:%p \n", des->next, * node);
    * node = des;  // 为链接下一个做准备
    printf("node=des %p:%p \n\n", * node, des);
  }
  printf("reverse_perfect end of node : %p \n", * node);
   1084c:	e51b3010 	ldr	r3, [fp, #-16]
   10850:	e5933000 	ldr	r3, [r3]
   10854:	e1a01003 	mov	r1, r3
   10858:	e59f0024 	ldr	r0, [pc, #36]	; 10884 <reverse_perfect_noreturn_debug+0x14c>
   1085c:	ebfffede 	bl	103dc <printf@plt>
}
   10860:	e24bd004 	sub	sp, fp, #4
   10864:	e8bd8800 	pop	{fp, pc}
   10868:	00011f0c 	.word	0x00011f0c
   1086c:	00011e80 	.word	0x00011e80
   10870:	00011e94 	.word	0x00011e94
   10874:	00011ea4 	.word	0x00011ea4
   10878:	00011eb4 	.word	0x00011eb4
   1087c:	00011ecc 	.word	0x00011ecc
   10880:	00011ee4 	.word	0x00011ee4
   10884:	00011f18 	.word	0x00011f18

00010888 <reverse_debug>:

struct list * reverse_debug(struct list * node)
{
   10888:	e92d4800 	push	{fp, lr}
   1088c:	e28db004 	add	fp, sp, #4
   10890:	e24dd020 	sub	sp, sp, #32
   10894:	e50b0018 	str	r0, [fp, #-24]	; 0xffffffe8
  struct list * src, * des, * tmp;

  tmp = node;
   10898:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   1089c:	e50b300c 	str	r3, [fp, #-12]
  printf("node:%p\n", node);
   108a0:	e51b1018 	ldr	r1, [fp, #-24]	; 0xffffffe8
   108a4:	e59f0278 	ldr	r0, [pc, #632]	; 10b24 <reverse_debug+0x29c>
   108a8:	ebfffecb 	bl	103dc <printf@plt>
  while(tmp != NULL) {
   108ac:	ea000005 	b	108c8 <reverse_debug+0x40>
    printf(" [[%p]] ", tmp);
   108b0:	e51b100c 	ldr	r1, [fp, #-12]
   108b4:	e59f026c 	ldr	r0, [pc, #620]	; 10b28 <reverse_debug+0x2a0>
   108b8:	ebfffec7 	bl	103dc <printf@plt>
    tmp = tmp->next;
   108bc:	e51b300c 	ldr	r3, [fp, #-12]
   108c0:	e5933004 	ldr	r3, [r3, #4]
   108c4:	e50b300c 	str	r3, [fp, #-12]
{
  struct list * src, * des, * tmp;

  tmp = node;
  printf("node:%p\n", node);
  while(tmp != NULL) {
   108c8:	e51b300c 	ldr	r3, [fp, #-12]
   108cc:	e3530000 	cmp	r3, #0
   108d0:	1afffff6 	bne	108b0 <reverse_debug+0x28>
    printf(" [[%p]] ", tmp);
    tmp = tmp->next;
  }
  printf("\n");
   108d4:	e3a0000a 	mov	r0, #10
   108d8:	ebfffebc 	bl	103d0 <putchar@plt>
  printf("%p: %p: %p: %p: %p\n", node, node->next, node->next->next, node->next->next->next, node->next->next->next->next);
   108dc:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   108e0:	e5931004 	ldr	r1, [r3, #4]
   108e4:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   108e8:	e5933004 	ldr	r3, [r3, #4]
   108ec:	e5930004 	ldr	r0, [r3, #4]
   108f0:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   108f4:	e5933004 	ldr	r3, [r3, #4]
   108f8:	e5933004 	ldr	r3, [r3, #4]
   108fc:	e5933004 	ldr	r3, [r3, #4]
   10900:	e51b2018 	ldr	r2, [fp, #-24]	; 0xffffffe8
   10904:	e5922004 	ldr	r2, [r2, #4]
   10908:	e5922004 	ldr	r2, [r2, #4]
   1090c:	e5922004 	ldr	r2, [r2, #4]
   10910:	e5922004 	ldr	r2, [r2, #4]
   10914:	e58d2004 	str	r2, [sp, #4]
   10918:	e58d3000 	str	r3, [sp]
   1091c:	e1a03000 	mov	r3, r0
   10920:	e1a02001 	mov	r2, r1
   10924:	e51b1018 	ldr	r1, [fp, #-24]	; 0xffffffe8
   10928:	e59f01fc 	ldr	r0, [pc, #508]	; 10b2c <reverse_debug+0x2a4>
   1092c:	ebfffeaa 	bl	103dc <printf@plt>
  printf("%d:%11d:%11d:%11d:%11d\n", node->num, node->next->num, node->next->next->num, node->next->next->next->num, 
   10930:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10934:	e5931000 	ldr	r1, [r3]
   10938:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   1093c:	e5933004 	ldr	r3, [r3, #4]
   10940:	e5930000 	ldr	r0, [r3]
   10944:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10948:	e5933004 	ldr	r3, [r3, #4]
   1094c:	e5933004 	ldr	r3, [r3, #4]
   10950:	e593c000 	ldr	ip, [r3]
   10954:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10958:	e5933004 	ldr	r3, [r3, #4]
   1095c:	e5933004 	ldr	r3, [r3, #4]
   10960:	e5933004 	ldr	r3, [r3, #4]
   10964:	e5933000 	ldr	r3, [r3]
	 node->next->next->next->next->num);
   10968:	e51b2018 	ldr	r2, [fp, #-24]	; 0xffffffe8
   1096c:	e5922004 	ldr	r2, [r2, #4]
   10970:	e5922004 	ldr	r2, [r2, #4]
   10974:	e5922004 	ldr	r2, [r2, #4]
   10978:	e5922004 	ldr	r2, [r2, #4]
    printf(" [[%p]] ", tmp);
    tmp = tmp->next;
  }
  printf("\n");
  printf("%p: %p: %p: %p: %p\n", node, node->next, node->next->next, node->next->next->next, node->next->next->next->next);
  printf("%d:%11d:%11d:%11d:%11d\n", node->num, node->next->num, node->next->next->num, node->next->next->next->num, 
   1097c:	e5922000 	ldr	r2, [r2]
   10980:	e58d2004 	str	r2, [sp, #4]
   10984:	e58d3000 	str	r3, [sp]
   10988:	e1a0300c 	mov	r3, ip
   1098c:	e1a02000 	mov	r2, r0
   10990:	e59f0198 	ldr	r0, [pc, #408]	; 10b30 <reverse_debug+0x2a8>
   10994:	ebfffe90 	bl	103dc <printf@plt>
	 node->next->next->next->next->num);

  src = node->next;  // 指向第二个数据节点
   10998:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   1099c:	e5933004 	ldr	r3, [r3, #4]
   109a0:	e50b3008 	str	r3, [fp, #-8]
  printf(" src=node->next:[%p:%d] [%p:%d]\n", src, src->num, node->next, node->next->num); 
   109a4:	e51b3008 	ldr	r3, [fp, #-8]
   109a8:	e5932000 	ldr	r2, [r3]
   109ac:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   109b0:	e5931004 	ldr	r1, [r3, #4]
   109b4:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   109b8:	e5933004 	ldr	r3, [r3, #4]
   109bc:	e5933000 	ldr	r3, [r3]
   109c0:	e58d3000 	str	r3, [sp]
   109c4:	e1a03001 	mov	r3, r1
   109c8:	e51b1008 	ldr	r1, [fp, #-8]
   109cc:	e59f0160 	ldr	r0, [pc, #352]	; 10b34 <reverse_debug+0x2ac>
   109d0:	ebfffe81 	bl	103dc <printf@plt>
  node->next = NULL; // 将原链表置为空
   109d4:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   109d8:	e3a02000 	mov	r2, #0
   109dc:	e5832004 	str	r2, [r3, #4]
  printf(" node->next=NULL [%p:%d]\n\n ", node->next, node->num); 
   109e0:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   109e4:	e5931004 	ldr	r1, [r3, #4]
   109e8:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   109ec:	e5933000 	ldr	r3, [r3]
   109f0:	e1a02003 	mov	r2, r3
   109f4:	e59f013c 	ldr	r0, [pc, #316]	; 10b38 <reverse_debug+0x2b0>
   109f8:	ebfffe77 	bl	103dc <printf@plt>
  
  while (src) {
   109fc:	ea00003e 	b	10afc <reverse_debug+0x274>
    printf(" while->src=[%p:%d] \n", src,  src->num); 
   10a00:	e51b3008 	ldr	r3, [fp, #-8]
   10a04:	e5933000 	ldr	r3, [r3]
   10a08:	e1a02003 	mov	r2, r3
   10a0c:	e51b1008 	ldr	r1, [fp, #-8]
   10a10:	e59f0124 	ldr	r0, [pc, #292]	; 10b3c <reverse_debug+0x2b4>
   10a14:	ebfffe70 	bl	103dc <printf@plt>
    des = src;
   10a18:	e51b3008 	ldr	r3, [fp, #-8]
   10a1c:	e50b3010 	str	r3, [fp, #-16]
    printf(" des=src des:[%p:%d] src:[%p:%d]\n", des, des->num, src, src->num);
   10a20:	e51b3010 	ldr	r3, [fp, #-16]
   10a24:	e5932000 	ldr	r2, [r3]
   10a28:	e51b3008 	ldr	r3, [fp, #-8]
   10a2c:	e5933000 	ldr	r3, [r3]
   10a30:	e58d3000 	str	r3, [sp]
   10a34:	e51b3008 	ldr	r3, [fp, #-8]
   10a38:	e51b1010 	ldr	r1, [fp, #-16]
   10a3c:	e59f00fc 	ldr	r0, [pc, #252]	; 10b40 <reverse_debug+0x2b8>
   10a40:	ebfffe65 	bl	103dc <printf@plt>
    src = src->next;
   10a44:	e51b3008 	ldr	r3, [fp, #-8]
   10a48:	e5933004 	ldr	r3, [r3, #4]
   10a4c:	e50b3008 	str	r3, [fp, #-8]
    printf(" src=src->next[%p]", src);
   10a50:	e51b1008 	ldr	r1, [fp, #-8]
   10a54:	e59f00e8 	ldr	r0, [pc, #232]	; 10b44 <reverse_debug+0x2bc>
   10a58:	ebfffe5f 	bl	103dc <printf@plt>
    if (src != NULL)
   10a5c:	e51b3008 	ldr	r3, [fp, #-8]
   10a60:	e3530000 	cmp	r3, #0
   10a64:	0a000005 	beq	10a80 <reverse_debug+0x1f8>
      printf(":[%d]\n", src->num);
   10a68:	e51b3008 	ldr	r3, [fp, #-8]
   10a6c:	e5933000 	ldr	r3, [r3]
   10a70:	e1a01003 	mov	r1, r3
   10a74:	e59f00cc 	ldr	r0, [pc, #204]	; 10b48 <reverse_debug+0x2c0>
   10a78:	ebfffe57 	bl	103dc <printf@plt>
   10a7c:	ea000001 	b	10a88 <reverse_debug+0x200>
    else
      printf("[blank]\n");
   10a80:	e59f00c4 	ldr	r0, [pc, #196]	; 10b4c <reverse_debug+0x2c4>
   10a84:	ebfffe57 	bl	103e8 <puts@plt>
    des->next = node->next; // 将当前节点插到头节点的后面
   10a88:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10a8c:	e5932004 	ldr	r2, [r3, #4]
   10a90:	e51b3010 	ldr	r3, [fp, #-16]
   10a94:	e5832004 	str	r2, [r3, #4]
    printf(" des->next=node->next [%p:%d]%p\n", des->next, des->num, node->next);
   10a98:	e51b3010 	ldr	r3, [fp, #-16]
   10a9c:	e5931004 	ldr	r1, [r3, #4]
   10aa0:	e51b3010 	ldr	r3, [fp, #-16]
   10aa4:	e5932000 	ldr	r2, [r3]
   10aa8:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10aac:	e5933004 	ldr	r3, [r3, #4]
   10ab0:	e59f0098 	ldr	r0, [pc, #152]	; 10b50 <reverse_debug+0x2c8>
   10ab4:	ebfffe48 	bl	103dc <printf@plt>
    node->next = des;
   10ab8:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10abc:	e51b2010 	ldr	r2, [fp, #-16]
   10ac0:	e5832004 	str	r2, [r3, #4]
    printf(" node->next=des [%p:%d]<=>[%p:%d]\n", node->next, node->next->num, des, des->num);
   10ac4:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10ac8:	e5931004 	ldr	r1, [r3, #4]
   10acc:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10ad0:	e5933004 	ldr	r3, [r3, #4]
   10ad4:	e5932000 	ldr	r2, [r3]
   10ad8:	e51b3010 	ldr	r3, [fp, #-16]
   10adc:	e5933000 	ldr	r3, [r3]
   10ae0:	e58d3000 	str	r3, [sp]
   10ae4:	e51b3010 	ldr	r3, [fp, #-16]
   10ae8:	e59f0064 	ldr	r0, [pc, #100]	; 10b54 <reverse_debug+0x2cc>
   10aec:	ebfffe3a 	bl	103dc <printf@plt>
    printf("while once end node:[%p] \n\n", node);
   10af0:	e51b1018 	ldr	r1, [fp, #-24]	; 0xffffffe8
   10af4:	e59f005c 	ldr	r0, [pc, #92]	; 10b58 <reverse_debug+0x2d0>
   10af8:	ebfffe37 	bl	103dc <printf@plt>
  src = node->next;  // 指向第二个数据节点
  printf(" src=node->next:[%p:%d] [%p:%d]\n", src, src->num, node->next, node->next->num); 
  node->next = NULL; // 将原链表置为空
  printf(" node->next=NULL [%p:%d]\n\n ", node->next, node->num); 
  
  while (src) {
   10afc:	e51b3008 	ldr	r3, [fp, #-8]
   10b00:	e3530000 	cmp	r3, #0
   10b04:	1affffbd 	bne	10a00 <reverse_debug+0x178>
    node->next = des;
    printf(" node->next=des [%p:%d]<=>[%p:%d]\n", node->next, node->next->num, des, des->num);
    printf("while once end node:[%p] \n\n", node);
  }
  
  printf("return node : [%p]\n\n", node);
   10b08:	e51b1018 	ldr	r1, [fp, #-24]	; 0xffffffe8
   10b0c:	e59f0048 	ldr	r0, [pc, #72]	; 10b5c <reverse_debug+0x2d4>
   10b10:	ebfffe31 	bl	103dc <printf@plt>

  return node;
   10b14:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
}
   10b18:	e1a00003 	mov	r0, r3
   10b1c:	e24bd004 	sub	sp, fp, #4
   10b20:	e8bd8800 	pop	{fp, pc}
   10b24:	00011f3c 	.word	0x00011f3c
   10b28:	00011f48 	.word	0x00011f48
   10b2c:	00011f54 	.word	0x00011f54
   10b30:	00011f68 	.word	0x00011f68
   10b34:	00011f80 	.word	0x00011f80
   10b38:	00011fa4 	.word	0x00011fa4
   10b3c:	00011fc0 	.word	0x00011fc0
   10b40:	00011fd8 	.word	0x00011fd8
   10b44:	00011ffc 	.word	0x00011ffc
   10b48:	00012010 	.word	0x00012010
   10b4c:	00012018 	.word	0x00012018
   10b50:	00012020 	.word	0x00012020
   10b54:	00012044 	.word	0x00012044
   10b58:	00012068 	.word	0x00012068
   10b5c:	00012084 	.word	0x00012084

00010b60 <reverse_1>:


struct list * reverse_1(struct list * node)
{
   10b60:	e92d4800 	push	{fp, lr}
   10b64:	e28db004 	add	fp, sp, #4
   10b68:	e24dd020 	sub	sp, sp, #32
   10b6c:	e50b0010 	str	r0, [fp, #-16]
  struct list * src, * des;

  printf("%p: %p: %p: %p: %p: %p\n", node, node->next, node->next->next, node->next->next->next, node->next->next->next->next,
   10b70:	e51b3010 	ldr	r3, [fp, #-16]
   10b74:	e5930004 	ldr	r0, [r3, #4]
   10b78:	e51b3010 	ldr	r3, [fp, #-16]
   10b7c:	e5933004 	ldr	r3, [r3, #4]
   10b80:	e593c004 	ldr	ip, [r3, #4]
   10b84:	e51b3010 	ldr	r3, [fp, #-16]
   10b88:	e5933004 	ldr	r3, [r3, #4]
   10b8c:	e5933004 	ldr	r3, [r3, #4]
   10b90:	e5933004 	ldr	r3, [r3, #4]
   10b94:	e51b2010 	ldr	r2, [fp, #-16]
   10b98:	e5922004 	ldr	r2, [r2, #4]
   10b9c:	e5922004 	ldr	r2, [r2, #4]
   10ba0:	e5922004 	ldr	r2, [r2, #4]
   10ba4:	e5922004 	ldr	r2, [r2, #4]
	 node->next->next->next->next->next);
   10ba8:	e51b1010 	ldr	r1, [fp, #-16]
   10bac:	e5911004 	ldr	r1, [r1, #4]
   10bb0:	e5911004 	ldr	r1, [r1, #4]
   10bb4:	e5911004 	ldr	r1, [r1, #4]
   10bb8:	e5911004 	ldr	r1, [r1, #4]

struct list * reverse_1(struct list * node)
{
  struct list * src, * des;

  printf("%p: %p: %p: %p: %p: %p\n", node, node->next, node->next->next, node->next->next->next, node->next->next->next->next,
   10bbc:	e5911004 	ldr	r1, [r1, #4]
   10bc0:	e58d1008 	str	r1, [sp, #8]
   10bc4:	e58d2004 	str	r2, [sp, #4]
   10bc8:	e58d3000 	str	r3, [sp]
   10bcc:	e1a0300c 	mov	r3, ip
   10bd0:	e1a02000 	mov	r2, r0
   10bd4:	e51b1010 	ldr	r1, [fp, #-16]
   10bd8:	e59f00f4 	ldr	r0, [pc, #244]	; 10cd4 <reverse_1+0x174>
   10bdc:	ebfffdfe 	bl	103dc <printf@plt>
	 node->next->next->next->next->next);
  src = node->next;
   10be0:	e51b3010 	ldr	r3, [fp, #-16]
   10be4:	e5933004 	ldr	r3, [r3, #4]
   10be8:	e50b3008 	str	r3, [fp, #-8]
  printf("src = node->next  %p:%p\n\n", src, node->next);
   10bec:	e51b3010 	ldr	r3, [fp, #-16]
   10bf0:	e5933004 	ldr	r3, [r3, #4]
   10bf4:	e1a02003 	mov	r2, r3
   10bf8:	e51b1008 	ldr	r1, [fp, #-8]
   10bfc:	e59f00d4 	ldr	r0, [pc, #212]	; 10cd8 <reverse_1+0x178>
   10c00:	ebfffdf5 	bl	103dc <printf@plt>
  while (src->next != NULL) {
   10c04:	ea000027 	b	10ca8 <reverse_1+0x148>
    des = src->next;
   10c08:	e51b3008 	ldr	r3, [fp, #-8]
   10c0c:	e5933004 	ldr	r3, [r3, #4]
   10c10:	e50b300c 	str	r3, [fp, #-12]
    printf("des = src->next  %p:%p\n", des, src->next);
   10c14:	e51b3008 	ldr	r3, [fp, #-8]
   10c18:	e5933004 	ldr	r3, [r3, #4]
   10c1c:	e1a02003 	mov	r2, r3
   10c20:	e51b100c 	ldr	r1, [fp, #-12]
   10c24:	e59f00b0 	ldr	r0, [pc, #176]	; 10cdc <reverse_1+0x17c>
   10c28:	ebfffdeb 	bl	103dc <printf@plt>
    src->next = des->next;
   10c2c:	e51b300c 	ldr	r3, [fp, #-12]
   10c30:	e5932004 	ldr	r2, [r3, #4]
   10c34:	e51b3008 	ldr	r3, [fp, #-8]
   10c38:	e5832004 	str	r2, [r3, #4]
    printf("src->next = des->next  %p:%p\n", src->next, des->next);
   10c3c:	e51b3008 	ldr	r3, [fp, #-8]
   10c40:	e5931004 	ldr	r1, [r3, #4]
   10c44:	e51b300c 	ldr	r3, [fp, #-12]
   10c48:	e5933004 	ldr	r3, [r3, #4]
   10c4c:	e1a02003 	mov	r2, r3
   10c50:	e59f0088 	ldr	r0, [pc, #136]	; 10ce0 <reverse_1+0x180>
   10c54:	ebfffde0 	bl	103dc <printf@plt>
    des->next = node->next;
   10c58:	e51b3010 	ldr	r3, [fp, #-16]
   10c5c:	e5932004 	ldr	r2, [r3, #4]
   10c60:	e51b300c 	ldr	r3, [fp, #-12]
   10c64:	e5832004 	str	r2, [r3, #4]
    printf("des->next = node->next  %p:%p\n", des->next, node->next);
   10c68:	e51b300c 	ldr	r3, [fp, #-12]
   10c6c:	e5931004 	ldr	r1, [r3, #4]
   10c70:	e51b3010 	ldr	r3, [fp, #-16]
   10c74:	e5933004 	ldr	r3, [r3, #4]
   10c78:	e1a02003 	mov	r2, r3
   10c7c:	e59f0060 	ldr	r0, [pc, #96]	; 10ce4 <reverse_1+0x184>
   10c80:	ebfffdd5 	bl	103dc <printf@plt>
    node->next = des;
   10c84:	e51b3010 	ldr	r3, [fp, #-16]
   10c88:	e51b200c 	ldr	r2, [fp, #-12]
   10c8c:	e5832004 	str	r2, [r3, #4]
    printf("node->next = des  %p:%p\n\n", node->next, des);
   10c90:	e51b3010 	ldr	r3, [fp, #-16]
   10c94:	e5933004 	ldr	r3, [r3, #4]
   10c98:	e51b200c 	ldr	r2, [fp, #-12]
   10c9c:	e1a01003 	mov	r1, r3
   10ca0:	e59f0040 	ldr	r0, [pc, #64]	; 10ce8 <reverse_1+0x188>
   10ca4:	ebfffdcc 	bl	103dc <printf@plt>

  printf("%p: %p: %p: %p: %p: %p\n", node, node->next, node->next->next, node->next->next->next, node->next->next->next->next,
	 node->next->next->next->next->next);
  src = node->next;
  printf("src = node->next  %p:%p\n\n", src, node->next);
  while (src->next != NULL) {
   10ca8:	e51b3008 	ldr	r3, [fp, #-8]
   10cac:	e5933004 	ldr	r3, [r3, #4]
   10cb0:	e3530000 	cmp	r3, #0
   10cb4:	1affffd3 	bne	10c08 <reverse_1+0xa8>
    des->next = node->next;
    printf("des->next = node->next  %p:%p\n", des->next, node->next);
    node->next = des;
    printf("node->next = des  %p:%p\n\n", node->next, des);
  }
  printf("reverse_1 end of node %p\n", node);
   10cb8:	e51b1010 	ldr	r1, [fp, #-16]
   10cbc:	e59f0028 	ldr	r0, [pc, #40]	; 10cec <reverse_1+0x18c>
   10cc0:	ebfffdc5 	bl	103dc <printf@plt>

  return node;
   10cc4:	e51b3010 	ldr	r3, [fp, #-16]
}
   10cc8:	e1a00003 	mov	r0, r3
   10ccc:	e24bd004 	sub	sp, fp, #4
   10cd0:	e8bd8800 	pop	{fp, pc}
   10cd4:	0001209c 	.word	0x0001209c
   10cd8:	000120b4 	.word	0x000120b4
   10cdc:	000120d0 	.word	0x000120d0
   10ce0:	000120e8 	.word	0x000120e8
   10ce4:	00012108 	.word	0x00012108
   10ce8:	00012128 	.word	0x00012128
   10cec:	00012144 	.word	0x00012144

00010cf0 <reverse_2>:

struct list * reverse_2(struct list * node)
{
   10cf0:	e92d4800 	push	{fp, lr}
   10cf4:	e28db004 	add	fp, sp, #4
   10cf8:	e24dd018 	sub	sp, sp, #24
   10cfc:	e50b0018 	str	r0, [fp, #-24]	; 0xffffffe8
  struct list * src, * pnext, * prev;

  src = node->next;
   10d00:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10d04:	e5933004 	ldr	r3, [r3, #4]
   10d08:	e50b3008 	str	r3, [fp, #-8]
  printf("src = node->next %p:%p\n", src, node->next);
   10d0c:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10d10:	e5933004 	ldr	r3, [r3, #4]
   10d14:	e1a02003 	mov	r2, r3
   10d18:	e51b1008 	ldr	r1, [fp, #-8]
   10d1c:	e59f010c 	ldr	r0, [pc, #268]	; 10e30 <reverse_2+0x140>
   10d20:	ebfffdad 	bl	103dc <printf@plt>
  pnext = src->next;
   10d24:	e51b3008 	ldr	r3, [fp, #-8]
   10d28:	e5933004 	ldr	r3, [r3, #4]
   10d2c:	e50b300c 	str	r3, [fp, #-12]
  printf("pnext = src->next %p:%p\n", pnext, src->next);
   10d30:	e51b3008 	ldr	r3, [fp, #-8]
   10d34:	e5933004 	ldr	r3, [r3, #4]
   10d38:	e1a02003 	mov	r2, r3
   10d3c:	e51b100c 	ldr	r1, [fp, #-12]
   10d40:	e59f00ec 	ldr	r0, [pc, #236]	; 10e34 <reverse_2+0x144>
   10d44:	ebfffda4 	bl	103dc <printf@plt>
  src->next = NULL;
   10d48:	e51b3008 	ldr	r3, [fp, #-8]
   10d4c:	e3a02000 	mov	r2, #0
   10d50:	e5832004 	str	r2, [r3, #4]
  printf("src->next = NULL %p\n\n", src->next);
   10d54:	e51b3008 	ldr	r3, [fp, #-8]
   10d58:	e5933004 	ldr	r3, [r3, #4]
   10d5c:	e1a01003 	mov	r1, r3
   10d60:	e59f00d0 	ldr	r0, [pc, #208]	; 10e38 <reverse_2+0x148>
   10d64:	ebfffd9c 	bl	103dc <printf@plt>
  while (pnext) {
   10d68:	ea000020 	b	10df0 <reverse_2+0x100>
    printf("pnext %p \n", pnext);
   10d6c:	e51b100c 	ldr	r1, [fp, #-12]
   10d70:	e59f00c4 	ldr	r0, [pc, #196]	; 10e3c <reverse_2+0x14c>
   10d74:	ebfffd98 	bl	103dc <printf@plt>
    prev = pnext->next;
   10d78:	e51b300c 	ldr	r3, [fp, #-12]
   10d7c:	e5933004 	ldr	r3, [r3, #4]
   10d80:	e50b3010 	str	r3, [fp, #-16]
    printf("prev = pnext->next %p:%p\n", prev, pnext->next);
   10d84:	e51b300c 	ldr	r3, [fp, #-12]
   10d88:	e5933004 	ldr	r3, [r3, #4]
   10d8c:	e1a02003 	mov	r2, r3
   10d90:	e51b1010 	ldr	r1, [fp, #-16]
   10d94:	e59f00a4 	ldr	r0, [pc, #164]	; 10e40 <reverse_2+0x150>
   10d98:	ebfffd8f 	bl	103dc <printf@plt>
    pnext->next = src;
   10d9c:	e51b300c 	ldr	r3, [fp, #-12]
   10da0:	e51b2008 	ldr	r2, [fp, #-8]
   10da4:	e5832004 	str	r2, [r3, #4]
    printf("pnext->next = src %p:%p\n", pnext->next, src);
   10da8:	e51b300c 	ldr	r3, [fp, #-12]
   10dac:	e5933004 	ldr	r3, [r3, #4]
   10db0:	e51b2008 	ldr	r2, [fp, #-8]
   10db4:	e1a01003 	mov	r1, r3
   10db8:	e59f0084 	ldr	r0, [pc, #132]	; 10e44 <reverse_2+0x154>
   10dbc:	ebfffd86 	bl	103dc <printf@plt>
    src = pnext;
   10dc0:	e51b300c 	ldr	r3, [fp, #-12]
   10dc4:	e50b3008 	str	r3, [fp, #-8]
    printf("src = pnext %p:%p\n", src, pnext);
   10dc8:	e51b200c 	ldr	r2, [fp, #-12]
   10dcc:	e51b1008 	ldr	r1, [fp, #-8]
   10dd0:	e59f0070 	ldr	r0, [pc, #112]	; 10e48 <reverse_2+0x158>
   10dd4:	ebfffd80 	bl	103dc <printf@plt>
    pnext = prev;
   10dd8:	e51b3010 	ldr	r3, [fp, #-16]
   10ddc:	e50b300c 	str	r3, [fp, #-12]
    printf("pnext = prev %p:%p\n\n", pnext, prev);
   10de0:	e51b2010 	ldr	r2, [fp, #-16]
   10de4:	e51b100c 	ldr	r1, [fp, #-12]
   10de8:	e59f005c 	ldr	r0, [pc, #92]	; 10e4c <reverse_2+0x15c>
   10dec:	ebfffd7a 	bl	103dc <printf@plt>
  printf("src = node->next %p:%p\n", src, node->next);
  pnext = src->next;
  printf("pnext = src->next %p:%p\n", pnext, src->next);
  src->next = NULL;
  printf("src->next = NULL %p\n\n", src->next);
  while (pnext) {
   10df0:	e51b300c 	ldr	r3, [fp, #-12]
   10df4:	e3530000 	cmp	r3, #0
   10df8:	1affffdb 	bne	10d6c <reverse_2+0x7c>
    src = pnext;
    printf("src = pnext %p:%p\n", src, pnext);
    pnext = prev;
    printf("pnext = prev %p:%p\n\n", pnext, prev);
  }
  node->next = src;
   10dfc:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10e00:	e51b2008 	ldr	r2, [fp, #-8]
   10e04:	e5832004 	str	r2, [r3, #4]
  printf("node->next = src %p:%p\n\n", node->next, src);
   10e08:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10e0c:	e5933004 	ldr	r3, [r3, #4]
   10e10:	e51b2008 	ldr	r2, [fp, #-8]
   10e14:	e1a01003 	mov	r1, r3
   10e18:	e59f0030 	ldr	r0, [pc, #48]	; 10e50 <reverse_2+0x160>
   10e1c:	ebfffd6e 	bl	103dc <printf@plt>

  return node;
   10e20:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
}
   10e24:	e1a00003 	mov	r0, r3
   10e28:	e24bd004 	sub	sp, fp, #4
   10e2c:	e8bd8800 	pop	{fp, pc}
   10e30:	00012160 	.word	0x00012160
   10e34:	00012178 	.word	0x00012178
   10e38:	00012194 	.word	0x00012194
   10e3c:	000121ac 	.word	0x000121ac
   10e40:	000121b8 	.word	0x000121b8
   10e44:	000121d4 	.word	0x000121d4
   10e48:	000121f0 	.word	0x000121f0
   10e4c:	00012204 	.word	0x00012204
   10e50:	0001221c 	.word	0x0001221c

00010e54 <merge_debug>:

struct list * merge_debug(struct list * first, struct list * second)
{
   10e54:	e92d4800 	push	{fp, lr}
   10e58:	e28db004 	add	fp, sp, #4
   10e5c:	e24dd010 	sub	sp, sp, #16
   10e60:	e50b0010 	str	r0, [fp, #-16]
   10e64:	e50b1014 	str	r1, [fp, #-20]	; 0xffffffec
  struct list * src;

  src = first;
   10e68:	e51b3010 	ldr	r3, [fp, #-16]
   10e6c:	e50b3008 	str	r3, [fp, #-8]
  printf("src first second %p:%p:%p\n\n", src, first, second);
   10e70:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   10e74:	e51b2010 	ldr	r2, [fp, #-16]
   10e78:	e51b1008 	ldr	r1, [fp, #-8]
   10e7c:	e59f007c 	ldr	r0, [pc, #124]	; 10f00 <merge_debug+0xac>
   10e80:	ebfffd55 	bl	103dc <printf@plt>
  while (src->next) { // 改为 src, 循环多一次，地址会跑飞，因而链不起来
   10e84:	ea00000b 	b	10eb8 <merge_debug+0x64>
    printf("while src src->next %p:%p \n", src, src->next);
   10e88:	e51b3008 	ldr	r3, [fp, #-8]
   10e8c:	e5933004 	ldr	r3, [r3, #4]
   10e90:	e1a02003 	mov	r2, r3
   10e94:	e51b1008 	ldr	r1, [fp, #-8]
   10e98:	e59f0064 	ldr	r0, [pc, #100]	; 10f04 <merge_debug+0xb0>
   10e9c:	ebfffd4e 	bl	103dc <printf@plt>
    src = src->next;
   10ea0:	e51b3008 	ldr	r3, [fp, #-8]
   10ea4:	e5933004 	ldr	r3, [r3, #4]
   10ea8:	e50b3008 	str	r3, [fp, #-8]
    printf("src = src->next  %p \n\n", src);
   10eac:	e51b1008 	ldr	r1, [fp, #-8]
   10eb0:	e59f0050 	ldr	r0, [pc, #80]	; 10f08 <merge_debug+0xb4>
   10eb4:	ebfffd48 	bl	103dc <printf@plt>
{
  struct list * src;

  src = first;
  printf("src first second %p:%p:%p\n\n", src, first, second);
  while (src->next) { // 改为 src, 循环多一次，地址会跑飞，因而链不起来
   10eb8:	e51b3008 	ldr	r3, [fp, #-8]
   10ebc:	e5933004 	ldr	r3, [r3, #4]
   10ec0:	e3530000 	cmp	r3, #0
   10ec4:	1affffef 	bne	10e88 <merge_debug+0x34>
    printf("while src src->next %p:%p \n", src, src->next);
    src = src->next;
    printf("src = src->next  %p \n\n", src);
  }
  printf("end whiel src %p \n", src);
   10ec8:	e51b1008 	ldr	r1, [fp, #-8]
   10ecc:	e59f0038 	ldr	r0, [pc, #56]	; 10f0c <merge_debug+0xb8>
   10ed0:	ebfffd41 	bl	103dc <printf@plt>
  src->next = second;
   10ed4:	e51b3008 	ldr	r3, [fp, #-8]
   10ed8:	e51b2014 	ldr	r2, [fp, #-20]	; 0xffffffec
   10edc:	e5832004 	str	r2, [r3, #4]
  printf("src first %p:%p\n", src, first);
   10ee0:	e51b2010 	ldr	r2, [fp, #-16]
   10ee4:	e51b1008 	ldr	r1, [fp, #-8]
   10ee8:	e59f0020 	ldr	r0, [pc, #32]	; 10f10 <merge_debug+0xbc>
   10eec:	ebfffd3a 	bl	103dc <printf@plt>

  return first;
   10ef0:	e51b3010 	ldr	r3, [fp, #-16]
}
   10ef4:	e1a00003 	mov	r0, r3
   10ef8:	e24bd004 	sub	sp, fp, #4
   10efc:	e8bd8800 	pop	{fp, pc}
   10f00:	00012238 	.word	0x00012238
   10f04:	00012254 	.word	0x00012254
   10f08:	00012270 	.word	0x00012270
   10f0c:	00012288 	.word	0x00012288
   10f10:	0001229c 	.word	0x0001229c

00010f14 <init_list>:
#include <stdio.h>
#include <stdlib.h>
#include "list.h"

void init_list(struct list ** list)
{
   10f14:	e92d4800 	push	{fp, lr}
   10f18:	e28db004 	add	fp, sp, #4
   10f1c:	e24dd008 	sub	sp, sp, #8
   10f20:	e50b0008 	str	r0, [fp, #-8]
  *list = malloc(sizeof(struct list));
   10f24:	e3a00008 	mov	r0, #8
   10f28:	ebfffd31 	bl	103f4 <malloc@plt>
   10f2c:	e1a03000 	mov	r3, r0
   10f30:	e1a02003 	mov	r2, r3
   10f34:	e51b3008 	ldr	r3, [fp, #-8]
   10f38:	e5832000 	str	r2, [r3]
  if (list == NULL)
   10f3c:	e51b3008 	ldr	r3, [fp, #-8]
   10f40:	e3530000 	cmp	r3, #0
   10f44:	1a000001 	bne	10f50 <init_list+0x3c>
    printf("init_list malloc fail.\n");
   10f48:	e59f0028 	ldr	r0, [pc, #40]	; 10f78 <init_list+0x64>
   10f4c:	ebfffd25 	bl	103e8 <puts@plt>
  
  (*list)->num = 0;
   10f50:	e51b3008 	ldr	r3, [fp, #-8]
   10f54:	e5933000 	ldr	r3, [r3]
   10f58:	e3a02000 	mov	r2, #0
   10f5c:	e5832000 	str	r2, [r3]
  (*list)->next = NULL;
   10f60:	e51b3008 	ldr	r3, [fp, #-8]
   10f64:	e5933000 	ldr	r3, [r3]
   10f68:	e3a02000 	mov	r2, #0
   10f6c:	e5832004 	str	r2, [r3, #4]
}
   10f70:	e24bd004 	sub	sp, fp, #4
   10f74:	e8bd8800 	pop	{fp, pc}
   10f78:	000122b0 	.word	0x000122b0

00010f7c <length>:

unsigned int length(struct list ** node)
{
   10f7c:	e52db004 	push	{fp}		; (str fp, [sp, #-4]!)
   10f80:	e28db000 	add	fp, sp, #0
   10f84:	e24dd014 	sub	sp, sp, #20
   10f88:	e50b0010 	str	r0, [fp, #-16]
  struct list * src;
  int len;

  src = * node;
   10f8c:	e51b3010 	ldr	r3, [fp, #-16]
   10f90:	e5933000 	ldr	r3, [r3]
   10f94:	e50b3008 	str	r3, [fp, #-8]
  while (src != NULL) {
   10f98:	ea000005 	b	10fb4 <length+0x38>
    len++;
   10f9c:	e51b300c 	ldr	r3, [fp, #-12]
   10fa0:	e2833001 	add	r3, r3, #1
   10fa4:	e50b300c 	str	r3, [fp, #-12]
    src = src->next;
   10fa8:	e51b3008 	ldr	r3, [fp, #-8]
   10fac:	e5933004 	ldr	r3, [r3, #4]
   10fb0:	e50b3008 	str	r3, [fp, #-8]
{
  struct list * src;
  int len;

  src = * node;
  while (src != NULL) {
   10fb4:	e51b3008 	ldr	r3, [fp, #-8]
   10fb8:	e3530000 	cmp	r3, #0
   10fbc:	1afffff6 	bne	10f9c <length+0x20>
    len++;
    src = src->next;
  }

  return len;
   10fc0:	e51b300c 	ldr	r3, [fp, #-12]
}
   10fc4:	e1a00003 	mov	r0, r3
   10fc8:	e24bd000 	sub	sp, fp, #0
   10fcc:	e49db004 	pop	{fp}		; (ldr fp, [sp], #4)
   10fd0:	e12fff1e 	bx	lr

00010fd4 <empty>:

int empty(struct list ** node)
{
   10fd4:	e52db004 	push	{fp}		; (str fp, [sp, #-4]!)
   10fd8:	e28db000 	add	fp, sp, #0
   10fdc:	e24dd014 	sub	sp, sp, #20
   10fe0:	e50b0010 	str	r0, [fp, #-16]
  struct list * src;

  src = * node;
   10fe4:	e51b3010 	ldr	r3, [fp, #-16]
   10fe8:	e5933000 	ldr	r3, [r3]
   10fec:	e50b3008 	str	r3, [fp, #-8]

  if (src != NULL)
   10ff0:	e51b3008 	ldr	r3, [fp, #-8]
   10ff4:	e3530000 	cmp	r3, #0
   10ff8:	0a000001 	beq	11004 <empty+0x30>
    return 1;
   10ffc:	e3a03001 	mov	r3, #1
   11000:	ea000000 	b	11008 <empty+0x34>
  else
    return 0;
   11004:	e3a03000 	mov	r3, #0
}
   11008:	e1a00003 	mov	r0, r3
   1100c:	e24bd000 	sub	sp, fp, #0
   11010:	e49db004 	pop	{fp}		; (ldr fp, [sp], #4)
   11014:	e12fff1e 	bx	lr

00011018 <clean_list>:

void clean_list(struct list ** node)
{
   11018:	e92d4800 	push	{fp, lr}
   1101c:	e28db004 	add	fp, sp, #4
   11020:	e24dd010 	sub	sp, sp, #16
   11024:	e50b0010 	str	r0, [fp, #-16]
  struct list * src, * des;

  src = * node;
   11028:	e51b3010 	ldr	r3, [fp, #-16]
   1102c:	e5933000 	ldr	r3, [r3]
   11030:	e50b3008 	str	r3, [fp, #-8]
  while (src != NULL) {
   11034:	ea000006 	b	11054 <clean_list+0x3c>
    des = src->next;
   11038:	e51b3008 	ldr	r3, [fp, #-8]
   1103c:	e5933004 	ldr	r3, [r3, #4]
   11040:	e50b300c 	str	r3, [fp, #-12]
    free(src);
   11044:	e51b0008 	ldr	r0, [fp, #-8]
   11048:	ebfffcf8 	bl	10430 <free@plt>
    src = des;
   1104c:	e51b300c 	ldr	r3, [fp, #-12]
   11050:	e50b3008 	str	r3, [fp, #-8]
void clean_list(struct list ** node)
{
  struct list * src, * des;

  src = * node;
  while (src != NULL) {
   11054:	e51b3008 	ldr	r3, [fp, #-8]
   11058:	e3530000 	cmp	r3, #0
   1105c:	1afffff5 	bne	11038 <clean_list+0x20>
    des = src->next;
    free(src);
    src = des;
  }
}
   11060:	e24bd004 	sub	sp, fp, #4
   11064:	e8bd8800 	pop	{fp, pc}

00011068 <display>:

void display(struct list ** node)
{
   11068:	e92d4800 	push	{fp, lr}
   1106c:	e28db004 	add	fp, sp, #4
   11070:	e24dd010 	sub	sp, sp, #16
   11074:	e50b0010 	str	r0, [fp, #-16]
  struct list * src;
  int i;
 
  src = * node;
   11078:	e51b3010 	ldr	r3, [fp, #-16]
   1107c:	e5933000 	ldr	r3, [r3]
   11080:	e50b3008 	str	r3, [fp, #-8]
  while (src) {
   11084:	ea000007 	b	110a8 <display+0x40>
    printf(" %d ", src->num);
   11088:	e51b3008 	ldr	r3, [fp, #-8]
   1108c:	e5933000 	ldr	r3, [r3]
   11090:	e1a01003 	mov	r1, r3
   11094:	e59f0028 	ldr	r0, [pc, #40]	; 110c4 <display+0x5c>
   11098:	ebfffccf 	bl	103dc <printf@plt>
    src = src->next;
   1109c:	e51b3008 	ldr	r3, [fp, #-8]
   110a0:	e5933004 	ldr	r3, [r3, #4]
   110a4:	e50b3008 	str	r3, [fp, #-8]
{
  struct list * src;
  int i;
 
  src = * node;
  while (src) {
   110a8:	e51b3008 	ldr	r3, [fp, #-8]
   110ac:	e3530000 	cmp	r3, #0
   110b0:	1afffff4 	bne	11088 <display+0x20>
    printf(" %d ", src->num);
    src = src->next;
  }

  printf("\n");
   110b4:	e3a0000a 	mov	r0, #10
   110b8:	ebfffcc4 	bl	103d0 <putchar@plt>
}
   110bc:	e24bd004 	sub	sp, fp, #4
   110c0:	e8bd8800 	pop	{fp, pc}
   110c4:	000122c8 	.word	0x000122c8

000110c8 <putout>:

void putout(struct list * node)
{
   110c8:	e92d4800 	push	{fp, lr}
   110cc:	e28db004 	add	fp, sp, #4
   110d0:	e24dd010 	sub	sp, sp, #16
   110d4:	e50b0010 	str	r0, [fp, #-16]
  struct list * src;

  if (!node)
   110d8:	e51b3010 	ldr	r3, [fp, #-16]
   110dc:	e3530000 	cmp	r3, #0
   110e0:	1a000000 	bne	110e8 <putout+0x20>
    return;
   110e4:	ea000010 	b	1112c <putout+0x64>
  
  src = node->next; // 会屏蔽掉第一节点，适合有头结点的链表
   110e8:	e51b3010 	ldr	r3, [fp, #-16]
   110ec:	e5933004 	ldr	r3, [r3, #4]
   110f0:	e50b3008 	str	r3, [fp, #-8]
  while (src) {
   110f4:	ea000007 	b	11118 <putout+0x50>
    printf(" %d ", src->num);
   110f8:	e51b3008 	ldr	r3, [fp, #-8]
   110fc:	e5933000 	ldr	r3, [r3]
   11100:	e1a01003 	mov	r1, r3
   11104:	e59f0028 	ldr	r0, [pc, #40]	; 11134 <putout+0x6c>
   11108:	ebfffcb3 	bl	103dc <printf@plt>
    src = src->next;
   1110c:	e51b3008 	ldr	r3, [fp, #-8]
   11110:	e5933004 	ldr	r3, [r3, #4]
   11114:	e50b3008 	str	r3, [fp, #-8]

  if (!node)
    return;
  
  src = node->next; // 会屏蔽掉第一节点，适合有头结点的链表
  while (src) {
   11118:	e51b3008 	ldr	r3, [fp, #-8]
   1111c:	e3530000 	cmp	r3, #0
   11120:	1afffff4 	bne	110f8 <putout+0x30>
    printf(" %d ", src->num);
    src = src->next;
  }
  printf("\n\n");
   11124:	e59f000c 	ldr	r0, [pc, #12]	; 11138 <putout+0x70>
   11128:	ebfffcae 	bl	103e8 <puts@plt>
}
   1112c:	e24bd004 	sub	sp, fp, #4
   11130:	e8bd8800 	pop	{fp, pc}
   11134:	000122c8 	.word	0x000122c8
   11138:	000122d0 	.word	0x000122d0

0001113c <insert_head>:

void insert_head(struct list ** node, int value)
{
   1113c:	e92d4800 	push	{fp, lr}
   11140:	e28db004 	add	fp, sp, #4
   11144:	e24dd010 	sub	sp, sp, #16
   11148:	e50b0010 	str	r0, [fp, #-16]
   1114c:	e50b1014 	str	r1, [fp, #-20]	; 0xffffffec
  struct list * des;

  des = (struct list *) malloc(sizeof(struct list));
   11150:	e3a00008 	mov	r0, #8
   11154:	ebfffca6 	bl	103f4 <malloc@plt>
   11158:	e1a03000 	mov	r3, r0
   1115c:	e50b3008 	str	r3, [fp, #-8]
  if (des == NULL) {
   11160:	e51b3008 	ldr	r3, [fp, #-8]
   11164:	e3530000 	cmp	r3, #0
   11168:	1a000002 	bne	11178 <insert_head+0x3c>
    printf("insert head malloc fail.\n");
   1116c:	e59f0034 	ldr	r0, [pc, #52]	; 111a8 <insert_head+0x6c>
   11170:	ebfffc9c 	bl	103e8 <puts@plt>
    return ;
   11174:	ea000009 	b	111a0 <insert_head+0x64>
  }
  des->num = value;
   11178:	e51b3008 	ldr	r3, [fp, #-8]
   1117c:	e51b2014 	ldr	r2, [fp, #-20]	; 0xffffffec
   11180:	e5832000 	str	r2, [r3]
  des->next = * node;
   11184:	e51b3010 	ldr	r3, [fp, #-16]
   11188:	e5932000 	ldr	r2, [r3]
   1118c:	e51b3008 	ldr	r3, [fp, #-8]
   11190:	e5832004 	str	r2, [r3, #4]
  * node = des;
   11194:	e51b3010 	ldr	r3, [fp, #-16]
   11198:	e51b2008 	ldr	r2, [fp, #-8]
   1119c:	e5832000 	str	r2, [r3]
}
   111a0:	e24bd004 	sub	sp, fp, #4
   111a4:	e8bd8800 	pop	{fp, pc}
   111a8:	000122d4 	.word	0x000122d4

000111ac <insert_tail>:

void insert_tail(struct list ** node, int value)
{
   111ac:	e92d4800 	push	{fp, lr}
   111b0:	e28db004 	add	fp, sp, #4
   111b4:	e24dd010 	sub	sp, sp, #16
   111b8:	e50b0010 	str	r0, [fp, #-16]
   111bc:	e50b1014 	str	r1, [fp, #-20]	; 0xffffffec
  struct list * src, * des;

  des = (struct list *) malloc(sizeof(struct list));
   111c0:	e3a00008 	mov	r0, #8
   111c4:	ebfffc8a 	bl	103f4 <malloc@plt>
   111c8:	e1a03000 	mov	r3, r0
   111cc:	e50b300c 	str	r3, [fp, #-12]
  if (des == NULL) {
   111d0:	e51b300c 	ldr	r3, [fp, #-12]
   111d4:	e3530000 	cmp	r3, #0
   111d8:	1a000002 	bne	111e8 <insert_tail+0x3c>
    printf("insert tail malloc fail.\n");
   111dc:	e59f007c 	ldr	r0, [pc, #124]	; 11260 <insert_tail+0xb4>
   111e0:	ebfffc80 	bl	103e8 <puts@plt>
    return ;
   111e4:	ea00001b 	b	11258 <insert_tail+0xac>
  }
  des->num = value;
   111e8:	e51b300c 	ldr	r3, [fp, #-12]
   111ec:	e51b2014 	ldr	r2, [fp, #-20]	; 0xffffffec
   111f0:	e5832000 	str	r2, [r3]
  des->next = NULL;
   111f4:	e51b300c 	ldr	r3, [fp, #-12]
   111f8:	e3a02000 	mov	r2, #0
   111fc:	e5832004 	str	r2, [r3, #4]

  src = * node;
   11200:	e51b3010 	ldr	r3, [fp, #-16]
   11204:	e5933000 	ldr	r3, [r3]
   11208:	e50b3008 	str	r3, [fp, #-8]
  if (* node == NULL) // 空
   1120c:	e51b3010 	ldr	r3, [fp, #-16]
   11210:	e5933000 	ldr	r3, [r3]
   11214:	e3530000 	cmp	r3, #0
   11218:	1a000003 	bne	1122c <insert_tail+0x80>
    * node = des;
   1121c:	e51b3010 	ldr	r3, [fp, #-16]
   11220:	e51b200c 	ldr	r2, [fp, #-12]
   11224:	e5832000 	str	r2, [r3]
   11228:	ea00000a 	b	11258 <insert_tail+0xac>
  else {
    while (src->next != NULL) // 非空
   1122c:	ea000002 	b	1123c <insert_tail+0x90>
      src = src->next; // 移到最后
   11230:	e51b3008 	ldr	r3, [fp, #-8]
   11234:	e5933004 	ldr	r3, [r3, #4]
   11238:	e50b3008 	str	r3, [fp, #-8]

  src = * node;
  if (* node == NULL) // 空
    * node = des;
  else {
    while (src->next != NULL) // 非空
   1123c:	e51b3008 	ldr	r3, [fp, #-8]
   11240:	e5933004 	ldr	r3, [r3, #4]
   11244:	e3530000 	cmp	r3, #0
   11248:	1afffff8 	bne	11230 <insert_tail+0x84>
      src = src->next; // 移到最后
    src->next = des;   // 在插入
   1124c:	e51b3008 	ldr	r3, [fp, #-8]
   11250:	e51b200c 	ldr	r2, [fp, #-12]
   11254:	e5832004 	str	r2, [r3, #4]
  }
}
   11258:	e24bd004 	sub	sp, fp, #4
   1125c:	e8bd8800 	pop	{fp, pc}
   11260:	000122f0 	.word	0x000122f0

00011264 <insert_pos_head>:

int insert_pos_head(struct list ** node, int value, int position)
{
   11264:	e92d4800 	push	{fp, lr}
   11268:	e28db004 	add	fp, sp, #4
   1126c:	e24dd028 	sub	sp, sp, #40	; 0x28
   11270:	e50b0020 	str	r0, [fp, #-32]	; 0xffffffe0
   11274:	e50b1024 	str	r1, [fp, #-36]	; 0xffffffdc
   11278:	e50b2028 	str	r2, [fp, #-40]	; 0xffffffd8
  struct list * src , * des,  * n, * p;
  int pos;

  src = * node;
   1127c:	e51b3020 	ldr	r3, [fp, #-32]	; 0xffffffe0
   11280:	e5933000 	ldr	r3, [r3]
   11284:	e50b3008 	str	r3, [fp, #-8]
  if (src == NULL)
   11288:	e51b3008 	ldr	r3, [fp, #-8]
   1128c:	e3530000 	cmp	r3, #0
   11290:	1a000001 	bne	1129c <insert_pos_head+0x38>
    return -1;
   11294:	e3e03000 	mvn	r3, #0
   11298:	ea000037 	b	1137c <insert_pos_head+0x118>

  if (length(node) < position) {
   1129c:	e51b0020 	ldr	r0, [fp, #-32]	; 0xffffffe0
   112a0:	ebffff35 	bl	10f7c <length>
   112a4:	e1a02000 	mov	r2, r0
   112a8:	e51b3028 	ldr	r3, [fp, #-40]	; 0xffffffd8
   112ac:	e1520003 	cmp	r2, r3
   112b0:	2a000003 	bcs	112c4 <insert_pos_head+0x60>
    printf("position too long!\n");
   112b4:	e59f00cc 	ldr	r0, [pc, #204]	; 11388 <insert_pos_head+0x124>
   112b8:	ebfffc4a 	bl	103e8 <puts@plt>
    return -1;
   112bc:	e3e03000 	mvn	r3, #0
   112c0:	ea00002d 	b	1137c <insert_pos_head+0x118>
  }

  des = (struct list *) malloc(sizeof(struct list));
   112c4:	e3a00008 	mov	r0, #8
   112c8:	ebfffc49 	bl	103f4 <malloc@plt>
   112cc:	e1a03000 	mov	r3, r0
   112d0:	e50b3010 	str	r3, [fp, #-16]
  if (des == NULL) {
   112d4:	e51b3010 	ldr	r3, [fp, #-16]
   112d8:	e3530000 	cmp	r3, #0
   112dc:	1a000003 	bne	112f0 <insert_pos_head+0x8c>
    printf("insert position head malloc fial.\n");
   112e0:	e59f00a4 	ldr	r0, [pc, #164]	; 1138c <insert_pos_head+0x128>
   112e4:	ebfffc3f 	bl	103e8 <puts@plt>
    return -1;
   112e8:	e3e03000 	mvn	r3, #0
   112ec:	ea000022 	b	1137c <insert_pos_head+0x118>
  }
  des->num = value;
   112f0:	e51b3010 	ldr	r3, [fp, #-16]
   112f4:	e51b2024 	ldr	r2, [fp, #-36]	; 0xffffffdc
   112f8:	e5832000 	str	r2, [r3]
  des->next = NULL;
   112fc:	e51b3010 	ldr	r3, [fp, #-16]
   11300:	e3a02000 	mov	r2, #0
   11304:	e5832004 	str	r2, [r3, #4]

  pos = 0;
   11308:	e3a03000 	mov	r3, #0
   1130c:	e50b300c 	str	r3, [fp, #-12]
  while (src != NULL) {
   11310:	ea000015 	b	1136c <insert_pos_head+0x108>
    pos++;
   11314:	e51b300c 	ldr	r3, [fp, #-12]
   11318:	e2833001 	add	r3, r3, #1
   1131c:	e50b300c 	str	r3, [fp, #-12]
    p = src;
   11320:	e51b3008 	ldr	r3, [fp, #-8]
   11324:	e50b3014 	str	r3, [fp, #-20]	; 0xffffffec
    src = src->next;
   11328:	e51b3008 	ldr	r3, [fp, #-8]
   1132c:	e5933004 	ldr	r3, [r3, #4]
   11330:	e50b3008 	str	r3, [fp, #-8]
    n = src;
   11334:	e51b3008 	ldr	r3, [fp, #-8]
   11338:	e50b3018 	str	r3, [fp, #-24]	; 0xffffffe8
    if (pos == position-1) { // 不-1 就插到后面了。
   1133c:	e51b3028 	ldr	r3, [fp, #-40]	; 0xffffffd8
   11340:	e2432001 	sub	r2, r3, #1
   11344:	e51b300c 	ldr	r3, [fp, #-12]
   11348:	e1520003 	cmp	r2, r3
   1134c:	1a000006 	bne	1136c <insert_pos_head+0x108>
      p->next = des;
   11350:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   11354:	e51b2010 	ldr	r2, [fp, #-16]
   11358:	e5832004 	str	r2, [r3, #4]
      des->next = n;
   1135c:	e51b3010 	ldr	r3, [fp, #-16]
   11360:	e51b2018 	ldr	r2, [fp, #-24]	; 0xffffffe8
   11364:	e5832004 	str	r2, [r3, #4]
      break;
   11368:	ea000002 	b	11378 <insert_pos_head+0x114>
  }
  des->num = value;
  des->next = NULL;

  pos = 0;
  while (src != NULL) {
   1136c:	e51b3008 	ldr	r3, [fp, #-8]
   11370:	e3530000 	cmp	r3, #0
   11374:	1affffe6 	bne	11314 <insert_pos_head+0xb0>
      des->next = n;
      break;
    }
  }

  return 0;
   11378:	e3a03000 	mov	r3, #0
}
   1137c:	e1a00003 	mov	r0, r3
   11380:	e24bd004 	sub	sp, fp, #4
   11384:	e8bd8800 	pop	{fp, pc}
   11388:	0001230c 	.word	0x0001230c
   1138c:	00012320 	.word	0x00012320

00011390 <insert_pos_tail>:


int insert_pos_tail(struct list ** node, int value, int position)
{
   11390:	e92d4800 	push	{fp, lr}
   11394:	e28db004 	add	fp, sp, #4
   11398:	e24dd020 	sub	sp, sp, #32
   1139c:	e50b0018 	str	r0, [fp, #-24]	; 0xffffffe8
   113a0:	e50b101c 	str	r1, [fp, #-28]	; 0xffffffe4
   113a4:	e50b2020 	str	r2, [fp, #-32]	; 0xffffffe0
  struct list * src , * des,  * n;
  int pos;

  src = * node;
   113a8:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   113ac:	e5933000 	ldr	r3, [r3]
   113b0:	e50b3008 	str	r3, [fp, #-8]
  if (src == NULL)
   113b4:	e51b3008 	ldr	r3, [fp, #-8]
   113b8:	e3530000 	cmp	r3, #0
   113bc:	1a000001 	bne	113c8 <insert_pos_tail+0x38>
    return -1;
   113c0:	e3e03000 	mvn	r3, #0
   113c4:	ea000036 	b	114a4 <insert_pos_tail+0x114>

  if (length(node) < position) {
   113c8:	e51b0018 	ldr	r0, [fp, #-24]	; 0xffffffe8
   113cc:	ebfffeea 	bl	10f7c <length>
   113d0:	e1a02000 	mov	r2, r0
   113d4:	e51b3020 	ldr	r3, [fp, #-32]	; 0xffffffe0
   113d8:	e1520003 	cmp	r2, r3
   113dc:	2a000003 	bcs	113f0 <insert_pos_tail+0x60>
    printf("position too long!\n");
   113e0:	e59f00c8 	ldr	r0, [pc, #200]	; 114b0 <insert_pos_tail+0x120>
   113e4:	ebfffbff 	bl	103e8 <puts@plt>
    return -1;
   113e8:	e3e03000 	mvn	r3, #0
   113ec:	ea00002c 	b	114a4 <insert_pos_tail+0x114>
  }

  des = (struct list *) malloc(sizeof(struct list));
   113f0:	e3a00008 	mov	r0, #8
   113f4:	ebfffbfe 	bl	103f4 <malloc@plt>
   113f8:	e1a03000 	mov	r3, r0
   113fc:	e50b3010 	str	r3, [fp, #-16]
  if (des == NULL) {
   11400:	e51b3010 	ldr	r3, [fp, #-16]
   11404:	e3530000 	cmp	r3, #0
   11408:	1a000003 	bne	1141c <insert_pos_tail+0x8c>
    printf("insert position head malloc fial.\n");
   1140c:	e59f00a0 	ldr	r0, [pc, #160]	; 114b4 <insert_pos_tail+0x124>
   11410:	ebfffbf4 	bl	103e8 <puts@plt>
    return -1;
   11414:	e3e03000 	mvn	r3, #0
   11418:	ea000021 	b	114a4 <insert_pos_tail+0x114>
  }
  des->num = value;
   1141c:	e51b3010 	ldr	r3, [fp, #-16]
   11420:	e51b201c 	ldr	r2, [fp, #-28]	; 0xffffffe4
   11424:	e5832000 	str	r2, [r3]
  des->next = NULL;
   11428:	e51b3010 	ldr	r3, [fp, #-16]
   1142c:	e3a02000 	mov	r2, #0
   11430:	e5832004 	str	r2, [r3, #4]

  pos = 0;
   11434:	e3a03000 	mov	r3, #0
   11438:	e50b300c 	str	r3, [fp, #-12]
  while (src != NULL) {
   1143c:	ea000014 	b	11494 <insert_pos_tail+0x104>
    pos++;
   11440:	e51b300c 	ldr	r3, [fp, #-12]
   11444:	e2833001 	add	r3, r3, #1
   11448:	e50b300c 	str	r3, [fp, #-12]
    src = src->next;
   1144c:	e51b3008 	ldr	r3, [fp, #-8]
   11450:	e5933004 	ldr	r3, [r3, #4]
   11454:	e50b3008 	str	r3, [fp, #-8]
    n = src;
   11458:	e51b3008 	ldr	r3, [fp, #-8]
   1145c:	e50b3014 	str	r3, [fp, #-20]	; 0xffffffec
    if (pos == position-1) { 
   11460:	e51b3020 	ldr	r3, [fp, #-32]	; 0xffffffe0
   11464:	e2432001 	sub	r2, r3, #1
   11468:	e51b300c 	ldr	r3, [fp, #-12]
   1146c:	e1520003 	cmp	r2, r3
   11470:	1a000007 	bne	11494 <insert_pos_tail+0x104>
      des->next = n->next;  // 指向 src 下一个结构体
   11474:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   11478:	e5932004 	ldr	r2, [r3, #4]
   1147c:	e51b3010 	ldr	r3, [fp, #-16]
   11480:	e5832004 	str	r2, [r3, #4]
      n->next = des;        // 把des 赋给当前 src 的成员 next
   11484:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   11488:	e51b2010 	ldr	r2, [fp, #-16]
   1148c:	e5832004 	str	r2, [r3, #4]
      break;
   11490:	ea000002 	b	114a0 <insert_pos_tail+0x110>
  }
  des->num = value;
  des->next = NULL;

  pos = 0;
  while (src != NULL) {
   11494:	e51b3008 	ldr	r3, [fp, #-8]
   11498:	e3530000 	cmp	r3, #0
   1149c:	1affffe7 	bne	11440 <insert_pos_tail+0xb0>
      n->next = des;        // 把des 赋给当前 src 的成员 next
      break;
    }
  }

  return 0;
   114a0:	e3a03000 	mov	r3, #0
}
   114a4:	e1a00003 	mov	r0, r3
   114a8:	e24bd004 	sub	sp, fp, #4
   114ac:	e8bd8800 	pop	{fp, pc}
   114b0:	0001230c 	.word	0x0001230c
   114b4:	00012320 	.word	0x00012320

000114b8 <delete_from_value>:

int delete_from_value(struct list ** node, int value)
{
   114b8:	e92d4800 	push	{fp, lr}
   114bc:	e28db004 	add	fp, sp, #4
   114c0:	e24dd010 	sub	sp, sp, #16
   114c4:	e50b0010 	str	r0, [fp, #-16]
   114c8:	e50b1014 	str	r1, [fp, #-20]	; 0xffffffec
  struct list * src, * cur;

  src = * node;
   114cc:	e51b3010 	ldr	r3, [fp, #-16]
   114d0:	e5933000 	ldr	r3, [r3]
   114d4:	e50b3008 	str	r3, [fp, #-8]
  cur = NULL;
   114d8:	e3a03000 	mov	r3, #0
   114dc:	e50b300c 	str	r3, [fp, #-12]
  while (src != NULL) {
   114e0:	ea00000a 	b	11510 <delete_from_value+0x58>
    if (src->num == value) {
   114e4:	e51b3008 	ldr	r3, [fp, #-8]
   114e8:	e5932000 	ldr	r2, [r3]
   114ec:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   114f0:	e1520003 	cmp	r2, r3
   114f4:	1a000000 	bne	114fc <delete_from_value+0x44>
      break;      
   114f8:	ea000007 	b	1151c <delete_from_value+0x64>
    }
    cur = src;
   114fc:	e51b3008 	ldr	r3, [fp, #-8]
   11500:	e50b300c 	str	r3, [fp, #-12]
    src = src->next;
   11504:	e51b3008 	ldr	r3, [fp, #-8]
   11508:	e5933004 	ldr	r3, [r3, #4]
   1150c:	e50b3008 	str	r3, [fp, #-8]
{
  struct list * src, * cur;

  src = * node;
  cur = NULL;
  while (src != NULL) {
   11510:	e51b3008 	ldr	r3, [fp, #-8]
   11514:	e3530000 	cmp	r3, #0
   11518:	1afffff1 	bne	114e4 <delete_from_value+0x2c>
    }
    cur = src;
    src = src->next;
  }

  if (cur == NULL)
   1151c:	e51b300c 	ldr	r3, [fp, #-12]
   11520:	e3530000 	cmp	r3, #0
   11524:	1a000005 	bne	11540 <delete_from_value+0x88>
    * node = (* node)->next;  // 指针后移， src 指向起始，故释放它
   11528:	e51b3010 	ldr	r3, [fp, #-16]
   1152c:	e5933000 	ldr	r3, [r3]
   11530:	e5932004 	ldr	r2, [r3, #4]
   11534:	e51b3010 	ldr	r3, [fp, #-16]
   11538:	e5832000 	str	r2, [r3]
   1153c:	ea000003 	b	11550 <delete_from_value+0x98>
  else
    cur->next = src->next;
   11540:	e51b3008 	ldr	r3, [fp, #-8]
   11544:	e5932004 	ldr	r2, [r3, #4]
   11548:	e51b300c 	ldr	r3, [fp, #-12]
   1154c:	e5832004 	str	r2, [r3, #4]

  free(src);
   11550:	e51b0008 	ldr	r0, [fp, #-8]
   11554:	ebfffbb5 	bl	10430 <free@plt>
  
  return 0;
   11558:	e3a03000 	mov	r3, #0
}
   1155c:	e1a00003 	mov	r0, r3
   11560:	e24bd004 	sub	sp, fp, #4
   11564:	e8bd8800 	pop	{fp, pc}

00011568 <delete_position>:

void delete_position(struct list ** node, int position)
{
   11568:	e92d4800 	push	{fp, lr}
   1156c:	e28db004 	add	fp, sp, #4
   11570:	e24dd018 	sub	sp, sp, #24
   11574:	e50b0018 	str	r0, [fp, #-24]	; 0xffffffe8
   11578:	e50b101c 	str	r1, [fp, #-28]	; 0xffffffe4
  struct list * src, * cur;
  int pos;

  src = * node;
   1157c:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   11580:	e5933000 	ldr	r3, [r3]
   11584:	e50b3008 	str	r3, [fp, #-8]
  if (src == NULL || position <= 0) {
   11588:	e51b3008 	ldr	r3, [fp, #-8]
   1158c:	e3530000 	cmp	r3, #0
   11590:	0a000002 	beq	115a0 <delete_position+0x38>
   11594:	e51b301c 	ldr	r3, [fp, #-28]	; 0xffffffe4
   11598:	e3530000 	cmp	r3, #0
   1159c:	ca000002 	bgt	115ac <delete_position+0x44>
    printf("node is null and position is zero.\n");
   115a0:	e59f00ac 	ldr	r0, [pc, #172]	; 11654 <delete_position+0xec>
   115a4:	ebfffb8f 	bl	103e8 <puts@plt>
    return ;
   115a8:	ea000027 	b	1164c <delete_position+0xe4>
  }

  pos = 0;
   115ac:	e3a03000 	mov	r3, #0
   115b0:	e50b3010 	str	r3, [fp, #-16]
  while (src != NULL) {
   115b4:	ea00000c 	b	115ec <delete_position+0x84>
    pos++;
   115b8:	e51b3010 	ldr	r3, [fp, #-16]
   115bc:	e2833001 	add	r3, r3, #1
   115c0:	e50b3010 	str	r3, [fp, #-16]
    if (pos == position)
   115c4:	e51b2010 	ldr	r2, [fp, #-16]
   115c8:	e51b301c 	ldr	r3, [fp, #-28]	; 0xffffffe4
   115cc:	e1520003 	cmp	r2, r3
   115d0:	1a000000 	bne	115d8 <delete_position+0x70>
      break;
   115d4:	ea000007 	b	115f8 <delete_position+0x90>
    cur = src;
   115d8:	e51b3008 	ldr	r3, [fp, #-8]
   115dc:	e50b300c 	str	r3, [fp, #-12]
    src = src->next;
   115e0:	e51b3008 	ldr	r3, [fp, #-8]
   115e4:	e5933004 	ldr	r3, [r3, #4]
   115e8:	e50b3008 	str	r3, [fp, #-8]
    printf("node is null and position is zero.\n");
    return ;
  }

  pos = 0;
  while (src != NULL) {
   115ec:	e51b3008 	ldr	r3, [fp, #-8]
   115f0:	e3530000 	cmp	r3, #0
   115f4:	1affffef 	bne	115b8 <delete_position+0x50>
      break;
    cur = src;
    src = src->next;
  }
  
  if (src == NULL) {
   115f8:	e51b3008 	ldr	r3, [fp, #-8]
   115fc:	e3530000 	cmp	r3, #0
   11600:	1a000002 	bne	11610 <delete_position+0xa8>
    printf("position value is error.\n");
   11604:	e59f004c 	ldr	r0, [pc, #76]	; 11658 <delete_position+0xf0>
   11608:	ebfffb76 	bl	103e8 <puts@plt>
    return ;
   1160c:	ea00000e 	b	1164c <delete_position+0xe4>
  }

  if (position == 1) 
   11610:	e51b301c 	ldr	r3, [fp, #-28]	; 0xffffffe4
   11614:	e3530001 	cmp	r3, #1
   11618:	1a000005 	bne	11634 <delete_position+0xcc>
    * node = (* node)->next;  // 指针后移， src 指向起始，故释放它
   1161c:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   11620:	e5933000 	ldr	r3, [r3]
   11624:	e5932004 	ldr	r2, [r3, #4]
   11628:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   1162c:	e5832000 	str	r2, [r3]
   11630:	ea000003 	b	11644 <delete_position+0xdc>
  else
    cur->next = src->next;
   11634:	e51b3008 	ldr	r3, [fp, #-8]
   11638:	e5932004 	ldr	r2, [r3, #4]
   1163c:	e51b300c 	ldr	r3, [fp, #-12]
   11640:	e5832004 	str	r2, [r3, #4]
  
  free(src);
   11644:	e51b0008 	ldr	r0, [fp, #-8]
   11648:	ebfffb78 	bl	10430 <free@plt>
}
   1164c:	e24bd004 	sub	sp, fp, #4
   11650:	e8bd8800 	pop	{fp, pc}
   11654:	00012344 	.word	0x00012344
   11658:	00012368 	.word	0x00012368

0001165c <delete_head>:

void delete_head(struct list ** node)
{
   1165c:	e92d4800 	push	{fp, lr}
   11660:	e28db004 	add	fp, sp, #4
   11664:	e24dd010 	sub	sp, sp, #16
   11668:	e50b0010 	str	r0, [fp, #-16]
  struct list * src;

  src = * node;
   1166c:	e51b3010 	ldr	r3, [fp, #-16]
   11670:	e5933000 	ldr	r3, [r3]
   11674:	e50b3008 	str	r3, [fp, #-8]
  if (src == NULL) {
   11678:	e51b3008 	ldr	r3, [fp, #-8]
   1167c:	e3530000 	cmp	r3, #0
   11680:	1a000002 	bne	11690 <delete_head+0x34>
    printf("list is empty.\n");
   11684:	e59f0028 	ldr	r0, [pc, #40]	; 116b4 <delete_head+0x58>
   11688:	ebfffb56 	bl	103e8 <puts@plt>
    return ;
   1168c:	ea000006 	b	116ac <delete_head+0x50>
  }
  
  * node = (* node)->next;   // 指针后移， src 指向起始，故释放它
   11690:	e51b3010 	ldr	r3, [fp, #-16]
   11694:	e5933000 	ldr	r3, [r3]
   11698:	e5932004 	ldr	r2, [r3, #4]
   1169c:	e51b3010 	ldr	r3, [fp, #-16]
   116a0:	e5832000 	str	r2, [r3]
  free(src);
   116a4:	e51b0008 	ldr	r0, [fp, #-8]
   116a8:	ebfffb60 	bl	10430 <free@plt>
}
   116ac:	e24bd004 	sub	sp, fp, #4
   116b0:	e8bd8800 	pop	{fp, pc}
   116b4:	00012384 	.word	0x00012384

000116b8 <delete_tail>:

void delete_tail(struct list ** node)
{
   116b8:	e92d4800 	push	{fp, lr}
   116bc:	e28db004 	add	fp, sp, #4
   116c0:	e24dd010 	sub	sp, sp, #16
   116c4:	e50b0010 	str	r0, [fp, #-16]
  struct list * src, * des;

  src = * node;
   116c8:	e51b3010 	ldr	r3, [fp, #-16]
   116cc:	e5933000 	ldr	r3, [r3]
   116d0:	e50b3008 	str	r3, [fp, #-8]
  des = NULL;
   116d4:	e3a03000 	mov	r3, #0
   116d8:	e50b300c 	str	r3, [fp, #-12]
  if (src == NULL) {
   116dc:	e51b3008 	ldr	r3, [fp, #-8]
   116e0:	e3530000 	cmp	r3, #0
   116e4:	1a000002 	bne	116f4 <delete_tail+0x3c>
    printf("list is empty.\n");
   116e8:	e59f0064 	ldr	r0, [pc, #100]	; 11754 <delete_tail+0x9c>
   116ec:	ebfffb3d 	bl	103e8 <puts@plt>
    return ;
   116f0:	ea000015 	b	1174c <delete_tail+0x94>
  }

  while (src->next != NULL) {
   116f4:	ea000004 	b	1170c <delete_tail+0x54>
    des = src;  // 指向了最后
   116f8:	e51b3008 	ldr	r3, [fp, #-8]
   116fc:	e50b300c 	str	r3, [fp, #-12]
    src = src->next;
   11700:	e51b3008 	ldr	r3, [fp, #-8]
   11704:	e5933004 	ldr	r3, [r3, #4]
   11708:	e50b3008 	str	r3, [fp, #-8]
  if (src == NULL) {
    printf("list is empty.\n");
    return ;
  }

  while (src->next != NULL) {
   1170c:	e51b3008 	ldr	r3, [fp, #-8]
   11710:	e5933004 	ldr	r3, [r3, #4]
   11714:	e3530000 	cmp	r3, #0
   11718:	1afffff6 	bne	116f8 <delete_tail+0x40>
    des = src;  // 指向了最后
    src = src->next;
  }

  if (des == NULL)
   1171c:	e51b300c 	ldr	r3, [fp, #-12]
   11720:	e3530000 	cmp	r3, #0
   11724:	1a000003 	bne	11738 <delete_tail+0x80>
    * node = NULL;
   11728:	e51b3010 	ldr	r3, [fp, #-16]
   1172c:	e3a02000 	mov	r2, #0
   11730:	e5832000 	str	r2, [r3]
   11734:	ea000002 	b	11744 <delete_tail+0x8c>
  else
    des->next = NULL;
   11738:	e51b300c 	ldr	r3, [fp, #-12]
   1173c:	e3a02000 	mov	r2, #0
   11740:	e5832004 	str	r2, [r3, #4]

  free(src);
   11744:	e51b0008 	ldr	r0, [fp, #-8]
   11748:	ebfffb38 	bl	10430 <free@plt>
}
   1174c:	e24bd004 	sub	sp, fp, #4
   11750:	e8bd8800 	pop	{fp, pc}
   11754:	00012384 	.word	0x00012384

00011758 <reverse>:

void reverse(struct list * node)
{
   11758:	e52db004 	push	{fp}		; (str fp, [sp, #-4]!)
   1175c:	e28db000 	add	fp, sp, #0
   11760:	e24dd014 	sub	sp, sp, #20
   11764:	e50b0010 	str	r0, [fp, #-16]
  struct list * src, * des;

  src = node->next;  // 指向第二个数据节点
   11768:	e51b3010 	ldr	r3, [fp, #-16]
   1176c:	e5933004 	ldr	r3, [r3, #4]
   11770:	e50b3008 	str	r3, [fp, #-8]
  node->next = NULL; // 将原链表置为空
   11774:	e51b3010 	ldr	r3, [fp, #-16]
   11778:	e3a02000 	mov	r2, #0
   1177c:	e5832004 	str	r2, [r3, #4]
  
  while (src) {
   11780:	ea00000b 	b	117b4 <reverse+0x5c>
    des = src;
   11784:	e51b3008 	ldr	r3, [fp, #-8]
   11788:	e50b300c 	str	r3, [fp, #-12]
    src = src->next;
   1178c:	e51b3008 	ldr	r3, [fp, #-8]
   11790:	e5933004 	ldr	r3, [r3, #4]
   11794:	e50b3008 	str	r3, [fp, #-8]
    des->next = node->next; // 将当前节点插到头节点的后面
   11798:	e51b3010 	ldr	r3, [fp, #-16]
   1179c:	e5932004 	ldr	r2, [r3, #4]
   117a0:	e51b300c 	ldr	r3, [fp, #-12]
   117a4:	e5832004 	str	r2, [r3, #4]
    node->next = des;
   117a8:	e51b3010 	ldr	r3, [fp, #-16]
   117ac:	e51b200c 	ldr	r2, [fp, #-12]
   117b0:	e5832004 	str	r2, [r3, #4]
  struct list * src, * des;

  src = node->next;  // 指向第二个数据节点
  node->next = NULL; // 将原链表置为空
  
  while (src) {
   117b4:	e51b3008 	ldr	r3, [fp, #-8]
   117b8:	e3530000 	cmp	r3, #0
   117bc:	1afffff0 	bne	11784 <reverse+0x2c>
    des = src;
    src = src->next;
    des->next = node->next; // 将当前节点插到头节点的后面
    node->next = des;
   }
}
   117c0:	e24bd000 	sub	sp, fp, #0
   117c4:	e49db004 	pop	{fp}		; (ldr fp, [sp], #4)
   117c8:	e12fff1e 	bx	lr

000117cc <reverse_perfect_return>:

struct list * reverse_perfect_return(struct list * node)
{
   117cc:	e52db004 	push	{fp}		; (str fp, [sp, #-4]!)
   117d0:	e28db000 	add	fp, sp, #0
   117d4:	e24dd014 	sub	sp, sp, #20
   117d8:	e50b0010 	str	r0, [fp, #-16]
  struct list * src, * des;

  src = node;
   117dc:	e51b3010 	ldr	r3, [fp, #-16]
   117e0:	e50b3008 	str	r3, [fp, #-8]
  node = NULL;
   117e4:	e3a03000 	mov	r3, #0
   117e8:	e50b3010 	str	r3, [fp, #-16]

  while (src) {
   117ec:	ea000009 	b	11818 <reverse_perfect_return+0x4c>
    des = src;
   117f0:	e51b3008 	ldr	r3, [fp, #-8]
   117f4:	e50b300c 	str	r3, [fp, #-12]
    src = src->next;
   117f8:	e51b3008 	ldr	r3, [fp, #-8]
   117fc:	e5933004 	ldr	r3, [r3, #4]
   11800:	e50b3008 	str	r3, [fp, #-8]
    des->next = node;
   11804:	e51b300c 	ldr	r3, [fp, #-12]
   11808:	e51b2010 	ldr	r2, [fp, #-16]
   1180c:	e5832004 	str	r2, [r3, #4]
    node = des;
   11810:	e51b300c 	ldr	r3, [fp, #-12]
   11814:	e50b3010 	str	r3, [fp, #-16]
  struct list * src, * des;

  src = node;
  node = NULL;

  while (src) {
   11818:	e51b3008 	ldr	r3, [fp, #-8]
   1181c:	e3530000 	cmp	r3, #0
   11820:	1afffff2 	bne	117f0 <reverse_perfect_return+0x24>
    src = src->next;
    des->next = node;
    node = des;
  }

  return node;
   11824:	e51b3010 	ldr	r3, [fp, #-16]
}
   11828:	e1a00003 	mov	r0, r3
   1182c:	e24bd000 	sub	sp, fp, #0
   11830:	e49db004 	pop	{fp}		; (ldr fp, [sp], #4)
   11834:	e12fff1e 	bx	lr

00011838 <reverse_perfect>:

void  reverse_perfect(struct list ** node)
{
   11838:	e52db004 	push	{fp}		; (str fp, [sp, #-4]!)
   1183c:	e28db000 	add	fp, sp, #0
   11840:	e24dd014 	sub	sp, sp, #20
   11844:	e50b0010 	str	r0, [fp, #-16]
  struct list * src, * des;

  src = * node;  // 指向第一个结点
   11848:	e51b3010 	ldr	r3, [fp, #-16]
   1184c:	e5933000 	ldr	r3, [r3]
   11850:	e50b3008 	str	r3, [fp, #-8]
  * node = NULL; // 目前，链表node为空 (num, next 都为空)
   11854:	e51b3010 	ldr	r3, [fp, #-16]
   11858:	e3a02000 	mov	r2, #0
   1185c:	e5832000 	str	r2, [r3]

  while (src) {
   11860:	ea00000b 	b	11894 <reverse_perfect+0x5c>
    des = src;          // des 指向要翻转的结点
   11864:	e51b3008 	ldr	r3, [fp, #-8]
   11868:	e50b300c 	str	r3, [fp, #-12]
    src = src->next;    // 指向下一个要翻转的结点
   1186c:	e51b3008 	ldr	r3, [fp, #-8]
   11870:	e5933004 	ldr	r3, [r3, #4]
   11874:	e50b3008 	str	r3, [fp, #-8]
    des->next = * node; // 链接到翻转后的链表
   11878:	e51b3010 	ldr	r3, [fp, #-16]
   1187c:	e5932000 	ldr	r2, [r3]
   11880:	e51b300c 	ldr	r3, [fp, #-12]
   11884:	e5832004 	str	r2, [r3, #4]
    * node = des;       // 为链接下一个做准备
   11888:	e51b3010 	ldr	r3, [fp, #-16]
   1188c:	e51b200c 	ldr	r2, [fp, #-12]
   11890:	e5832000 	str	r2, [r3]
  struct list * src, * des;

  src = * node;  // 指向第一个结点
  * node = NULL; // 目前，链表node为空 (num, next 都为空)

  while (src) {
   11894:	e51b3008 	ldr	r3, [fp, #-8]
   11898:	e3530000 	cmp	r3, #0
   1189c:	1afffff0 	bne	11864 <reverse_perfect+0x2c>
    des = src;          // des 指向要翻转的结点
    src = src->next;    // 指向下一个要翻转的结点
    des->next = * node; // 链接到翻转后的链表
    * node = des;       // 为链接下一个做准备
  }
}
   118a0:	e24bd000 	sub	sp, fp, #0
   118a4:	e49db004 	pop	{fp}		; (ldr fp, [sp], #4)
   118a8:	e12fff1e 	bx	lr

000118ac <reverse_dis>:

void reverse_dis(struct list * node)
{
   118ac:	e92d4800 	push	{fp, lr}
   118b0:	e28db004 	add	fp, sp, #4
   118b4:	e24dd008 	sub	sp, sp, #8
   118b8:	e50b0008 	str	r0, [fp, #-8]
  if (node != NULL) {
   118bc:	e51b3008 	ldr	r3, [fp, #-8]
   118c0:	e3530000 	cmp	r3, #0
   118c4:	0a000008 	beq	118ec <reverse_dis+0x40>
    reverse_dis(node->next);
   118c8:	e51b3008 	ldr	r3, [fp, #-8]
   118cc:	e5933004 	ldr	r3, [r3, #4]
   118d0:	e1a00003 	mov	r0, r3
   118d4:	ebfffff4 	bl	118ac <reverse_dis>
    printf(" %d", node->num);
   118d8:	e51b3008 	ldr	r3, [fp, #-8]
   118dc:	e5933000 	ldr	r3, [r3]
   118e0:	e1a01003 	mov	r1, r3
   118e4:	e59f0010 	ldr	r0, [pc, #16]	; 118fc <reverse_dis+0x50>
   118e8:	ebfffabb 	bl	103dc <printf@plt>
  }
  printf("\n");
   118ec:	e3a0000a 	mov	r0, #10
   118f0:	ebfffab6 	bl	103d0 <putchar@plt>
}
   118f4:	e24bd004 	sub	sp, fp, #4
   118f8:	e8bd8800 	pop	{fp, pc}
   118fc:	00012394 	.word	0x00012394

00011900 <merge>:

struct list * merge(struct list * first, struct list * second)
{
   11900:	e52db004 	push	{fp}		; (str fp, [sp, #-4]!)
   11904:	e28db000 	add	fp, sp, #0
   11908:	e24dd014 	sub	sp, sp, #20
   1190c:	e50b0010 	str	r0, [fp, #-16]
   11910:	e50b1014 	str	r1, [fp, #-20]	; 0xffffffec
  struct list * src;

  src = first;
   11914:	e51b3010 	ldr	r3, [fp, #-16]
   11918:	e50b3008 	str	r3, [fp, #-8]
  while (src->next)  // 改为 src, 循环多一次，地址会跑飞，因而链不起来
   1191c:	ea000002 	b	1192c <merge+0x2c>
    src = src->next;
   11920:	e51b3008 	ldr	r3, [fp, #-8]
   11924:	e5933004 	ldr	r3, [r3, #4]
   11928:	e50b3008 	str	r3, [fp, #-8]
struct list * merge(struct list * first, struct list * second)
{
  struct list * src;

  src = first;
  while (src->next)  // 改为 src, 循环多一次，地址会跑飞，因而链不起来
   1192c:	e51b3008 	ldr	r3, [fp, #-8]
   11930:	e5933004 	ldr	r3, [r3, #4]
   11934:	e3530000 	cmp	r3, #0
   11938:	1afffff8 	bne	11920 <merge+0x20>
    src = src->next;
  
  src->next = second;
   1193c:	e51b3008 	ldr	r3, [fp, #-8]
   11940:	e51b2014 	ldr	r2, [fp, #-20]	; 0xffffffec
   11944:	e5832004 	str	r2, [r3, #4]

  return first;
   11948:	e51b3010 	ldr	r3, [fp, #-16]
}
   1194c:	e1a00003 	mov	r0, r3
   11950:	e24bd000 	sub	sp, fp, #0
   11954:	e49db004 	pop	{fp}		; (ldr fp, [sp], #4)
   11958:	e12fff1e 	bx	lr

0001195c <merge_sort_recursion>:

struct list * merge_sort_recursion(struct list * first, struct list * second)
{
   1195c:	e92d4800 	push	{fp, lr}
   11960:	e28db004 	add	fp, sp, #4
   11964:	e24dd010 	sub	sp, sp, #16
   11968:	e50b0010 	str	r0, [fp, #-16]
   1196c:	e50b1014 	str	r1, [fp, #-20]	; 0xffffffec
  struct list * src;

  if (first == NULL)
   11970:	e51b3010 	ldr	r3, [fp, #-16]
   11974:	e3530000 	cmp	r3, #0
   11978:	1a000001 	bne	11984 <merge_sort_recursion+0x28>
    return second;
   1197c:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   11980:	ea000022 	b	11a10 <merge_sort_recursion+0xb4>
  else if (second == NULL)
   11984:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   11988:	e3530000 	cmp	r3, #0
   1198c:	1a000001 	bne	11998 <merge_sort_recursion+0x3c>
    return first;
   11990:	e51b3010 	ldr	r3, [fp, #-16]
   11994:	ea00001d 	b	11a10 <merge_sort_recursion+0xb4>

  src = NULL;
   11998:	e3a03000 	mov	r3, #0
   1199c:	e50b3008 	str	r3, [fp, #-8]
  if (first->num < second->num) {
   119a0:	e51b3010 	ldr	r3, [fp, #-16]
   119a4:	e5932000 	ldr	r2, [r3]
   119a8:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   119ac:	e5933000 	ldr	r3, [r3]
   119b0:	e1520003 	cmp	r2, r3
   119b4:	aa00000a 	bge	119e4 <merge_sort_recursion+0x88>
    src = first;
   119b8:	e51b3010 	ldr	r3, [fp, #-16]
   119bc:	e50b3008 	str	r3, [fp, #-8]
    src->next = merge_sort_recursion(first->next, second);
   119c0:	e51b3010 	ldr	r3, [fp, #-16]
   119c4:	e5933004 	ldr	r3, [r3, #4]
   119c8:	e51b1014 	ldr	r1, [fp, #-20]	; 0xffffffec
   119cc:	e1a00003 	mov	r0, r3
   119d0:	ebffffe1 	bl	1195c <merge_sort_recursion>
   119d4:	e1a02000 	mov	r2, r0
   119d8:	e51b3008 	ldr	r3, [fp, #-8]
   119dc:	e5832004 	str	r2, [r3, #4]
   119e0:	ea000009 	b	11a0c <merge_sort_recursion+0xb0>
  }
  else {
    src = second;
   119e4:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   119e8:	e50b3008 	str	r3, [fp, #-8]
    src->next = merge_sort_recursion(first, second->next);
   119ec:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   119f0:	e5933004 	ldr	r3, [r3, #4]
   119f4:	e1a01003 	mov	r1, r3
   119f8:	e51b0010 	ldr	r0, [fp, #-16]
   119fc:	ebffffd6 	bl	1195c <merge_sort_recursion>
   11a00:	e1a02000 	mov	r2, r0
   11a04:	e51b3008 	ldr	r3, [fp, #-8]
   11a08:	e5832004 	str	r2, [r3, #4]
  }

  return src;
   11a0c:	e51b3008 	ldr	r3, [fp, #-8]
}
   11a10:	e1a00003 	mov	r0, r3
   11a14:	e24bd004 	sub	sp, fp, #4
   11a18:	e8bd8800 	pop	{fp, pc}

00011a1c <merge_sort_>:

struct list * merge_sort_(struct list * first, struct list * second)
{
   11a1c:	e52db004 	push	{fp}		; (str fp, [sp, #-4]!)
   11a20:	e28db000 	add	fp, sp, #0
   11a24:	e24dd01c 	sub	sp, sp, #28
   11a28:	e50b0018 	str	r0, [fp, #-24]	; 0xffffffe8
   11a2c:	e50b101c 	str	r1, [fp, #-28]	; 0xffffffe4
  struct list * src, * pfirst, * psecond, * des;

  src = first;
   11a30:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   11a34:	e50b3014 	str	r3, [fp, #-20]	; 0xffffffec
  des = first;
   11a38:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   11a3c:	e50b3010 	str	r3, [fp, #-16]
  pfirst = first;
   11a40:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   11a44:	e50b3008 	str	r3, [fp, #-8]
  psecond = second;
   11a48:	e51b301c 	ldr	r3, [fp, #-28]	; 0xffffffe4
   11a4c:	e50b300c 	str	r3, [fp, #-12]

  while (pfirst && psecond) {
   11a50:	ea000027 	b	11af4 <merge_sort_+0xd8>
    if (pfirst == psecond) {
   11a54:	e51b2008 	ldr	r2, [fp, #-8]
   11a58:	e51b300c 	ldr	r3, [fp, #-12]
   11a5c:	e1520003 	cmp	r2, r3
   11a60:	1a000002 	bne	11a70 <merge_sort_+0x54>
      psecond = NULL;
   11a64:	e3a03000 	mov	r3, #0
   11a68:	e50b300c 	str	r3, [fp, #-12]
      break;
   11a6c:	ea000026 	b	11b0c <merge_sort_+0xf0>
    }
    else if (pfirst->num > psecond->num) {
   11a70:	e51b3008 	ldr	r3, [fp, #-8]
   11a74:	e5932000 	ldr	r2, [r3]
   11a78:	e51b300c 	ldr	r3, [fp, #-12]
   11a7c:	e5933000 	ldr	r3, [r3]
   11a80:	e1520003 	cmp	r2, r3
   11a84:	da00000c 	ble	11abc <merge_sort_+0xa0>
      des->next = psecond;
   11a88:	e51b3010 	ldr	r3, [fp, #-16]
   11a8c:	e51b200c 	ldr	r2, [fp, #-12]
   11a90:	e5832004 	str	r2, [r3, #4]
      psecond = psecond->next;
   11a94:	e51b300c 	ldr	r3, [fp, #-12]
   11a98:	e5933004 	ldr	r3, [r3, #4]
   11a9c:	e50b300c 	str	r3, [fp, #-12]
      des = des->next;
   11aa0:	e51b3010 	ldr	r3, [fp, #-16]
   11aa4:	e5933004 	ldr	r3, [r3, #4]
   11aa8:	e50b3010 	str	r3, [fp, #-16]
      des->next = pfirst;
   11aac:	e51b3010 	ldr	r3, [fp, #-16]
   11ab0:	e51b2008 	ldr	r2, [fp, #-8]
   11ab4:	e5832004 	str	r2, [r3, #4]
   11ab8:	ea00000d 	b	11af4 <merge_sort_+0xd8>
    }
    else {
      if (pfirst->next == psecond->next) {
   11abc:	e51b3008 	ldr	r3, [fp, #-8]
   11ac0:	e5932004 	ldr	r2, [r3, #4]
   11ac4:	e51b300c 	ldr	r3, [fp, #-12]
   11ac8:	e5933004 	ldr	r3, [r3, #4]
   11acc:	e1520003 	cmp	r2, r3
   11ad0:	1a000002 	bne	11ae0 <merge_sort_+0xc4>
	psecond->next = NULL;
   11ad4:	e51b300c 	ldr	r3, [fp, #-12]
   11ad8:	e3a02000 	mov	r2, #0
   11adc:	e5832004 	str	r2, [r3, #4]
      }
      des = pfirst;
   11ae0:	e51b3008 	ldr	r3, [fp, #-8]
   11ae4:	e50b3010 	str	r3, [fp, #-16]
      pfirst = pfirst->next;
   11ae8:	e51b3008 	ldr	r3, [fp, #-8]
   11aec:	e5933004 	ldr	r3, [r3, #4]
   11af0:	e50b3008 	str	r3, [fp, #-8]
  src = first;
  des = first;
  pfirst = first;
  psecond = second;

  while (pfirst && psecond) {
   11af4:	e51b3008 	ldr	r3, [fp, #-8]
   11af8:	e3530000 	cmp	r3, #0
   11afc:	0a000002 	beq	11b0c <merge_sort_+0xf0>
   11b00:	e51b300c 	ldr	r3, [fp, #-12]
   11b04:	e3530000 	cmp	r3, #0
   11b08:	1affffd1 	bne	11a54 <merge_sort_+0x38>
      des = pfirst;
      pfirst = pfirst->next;
    }
  }

  des->next = pfirst ? pfirst : psecond;
   11b0c:	e51b3008 	ldr	r3, [fp, #-8]
   11b10:	e3530000 	cmp	r3, #0
   11b14:	0a000001 	beq	11b20 <merge_sort_+0x104>
   11b18:	e51b3008 	ldr	r3, [fp, #-8]
   11b1c:	ea000000 	b	11b24 <merge_sort_+0x108>
   11b20:	e51b300c 	ldr	r3, [fp, #-12]
   11b24:	e51b2010 	ldr	r2, [fp, #-16]
   11b28:	e5823004 	str	r3, [r2, #4]

  return src;
   11b2c:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
}
   11b30:	e1a00003 	mov	r0, r3
   11b34:	e24bd000 	sub	sp, fp, #0
   11b38:	e49db004 	pop	{fp}		; (ldr fp, [sp], #4)
   11b3c:	e12fff1e 	bx	lr

00011b40 <merge_sort>:

struct list * merge_sort(struct list * first, struct list * second)
{
   11b40:	e92d4800 	push	{fp, lr}
   11b44:	e28db004 	add	fp, sp, #4
   11b48:	e24dd010 	sub	sp, sp, #16
   11b4c:	e50b0010 	str	r0, [fp, #-16]
   11b50:	e50b1014 	str	r1, [fp, #-20]	; 0xffffffec
  struct list * head, * src;

  if (first == NULL || first->next == NULL)
   11b54:	e51b3010 	ldr	r3, [fp, #-16]
   11b58:	e3530000 	cmp	r3, #0
   11b5c:	0a000003 	beq	11b70 <merge_sort+0x30>
   11b60:	e51b3010 	ldr	r3, [fp, #-16]
   11b64:	e5933004 	ldr	r3, [r3, #4]
   11b68:	e3530000 	cmp	r3, #0
   11b6c:	1a000001 	bne	11b78 <merge_sort+0x38>
    return second;
   11b70:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   11b74:	ea00006b 	b	11d28 <merge_sort+0x1e8>
  if (second == NULL || second->next == NULL)
   11b78:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   11b7c:	e3530000 	cmp	r3, #0
   11b80:	0a000003 	beq	11b94 <merge_sort+0x54>
   11b84:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   11b88:	e5933004 	ldr	r3, [r3, #4]
   11b8c:	e3530000 	cmp	r3, #0
   11b90:	1a000001 	bne	11b9c <merge_sort+0x5c>
    return first;
   11b94:	e51b3010 	ldr	r3, [fp, #-16]
   11b98:	ea000062 	b	11d28 <merge_sort+0x1e8>

  first = first->next;
   11b9c:	e51b3010 	ldr	r3, [fp, #-16]
   11ba0:	e5933004 	ldr	r3, [r3, #4]
   11ba4:	e50b3010 	str	r3, [fp, #-16]
  second = second->next;
   11ba8:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   11bac:	e5933004 	ldr	r3, [r3, #4]
   11bb0:	e50b3014 	str	r3, [fp, #-20]	; 0xffffffec

  head = (struct list *)malloc(sizeof(struct list));
   11bb4:	e3a00008 	mov	r0, #8
   11bb8:	ebfffa0d 	bl	103f4 <malloc@plt>
   11bbc:	e1a03000 	mov	r3, r0
   11bc0:	e50b300c 	str	r3, [fp, #-12]
  src = NULL;
   11bc4:	e3a03000 	mov	r3, #0
   11bc8:	e50b3008 	str	r3, [fp, #-8]

  if (first != NULL && second != NULL) {
   11bcc:	e51b3010 	ldr	r3, [fp, #-16]
   11bd0:	e3530000 	cmp	r3, #0
   11bd4:	0a000015 	beq	11c30 <merge_sort+0xf0>
   11bd8:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   11bdc:	e3530000 	cmp	r3, #0
   11be0:	0a000012 	beq	11c30 <merge_sort+0xf0>
    if (first->num <= second->num) {
   11be4:	e51b3010 	ldr	r3, [fp, #-16]
   11be8:	e5932000 	ldr	r2, [r3]
   11bec:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   11bf0:	e5933000 	ldr	r3, [r3]
   11bf4:	e1520003 	cmp	r2, r3
   11bf8:	ca000006 	bgt	11c18 <merge_sort+0xd8>
      head->next = first;
   11bfc:	e51b300c 	ldr	r3, [fp, #-12]
   11c00:	e51b2010 	ldr	r2, [fp, #-16]
   11c04:	e5832004 	str	r2, [r3, #4]
      first = first->next;
   11c08:	e51b3010 	ldr	r3, [fp, #-16]
   11c0c:	e5933004 	ldr	r3, [r3, #4]
   11c10:	e50b3010 	str	r3, [fp, #-16]
   11c14:	ea000005 	b	11c30 <merge_sort+0xf0>
    }
    else {
      head->next = second;
   11c18:	e51b300c 	ldr	r3, [fp, #-12]
   11c1c:	e51b2014 	ldr	r2, [fp, #-20]	; 0xffffffec
   11c20:	e5832004 	str	r2, [r3, #4]
      second = second->next;
   11c24:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   11c28:	e5933004 	ldr	r3, [r3, #4]
   11c2c:	e50b3014 	str	r3, [fp, #-20]	; 0xffffffec
    }
  }
   
  src = head->next;
   11c30:	e51b300c 	ldr	r3, [fp, #-12]
   11c34:	e5933004 	ldr	r3, [r3, #4]
   11c38:	e50b3008 	str	r3, [fp, #-8]

  while (first != NULL && second != NULL) {
   11c3c:	ea000018 	b	11ca4 <merge_sort+0x164>
    if (first->num <= second->num) {
   11c40:	e51b3010 	ldr	r3, [fp, #-16]
   11c44:	e5932000 	ldr	r2, [r3]
   11c48:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   11c4c:	e5933000 	ldr	r3, [r3]
   11c50:	e1520003 	cmp	r2, r3
   11c54:	ca000009 	bgt	11c80 <merge_sort+0x140>
      src->next = first;
   11c58:	e51b3008 	ldr	r3, [fp, #-8]
   11c5c:	e51b2010 	ldr	r2, [fp, #-16]
   11c60:	e5832004 	str	r2, [r3, #4]
      first = first->next;
   11c64:	e51b3010 	ldr	r3, [fp, #-16]
   11c68:	e5933004 	ldr	r3, [r3, #4]
   11c6c:	e50b3010 	str	r3, [fp, #-16]
      src = src->next;
   11c70:	e51b3008 	ldr	r3, [fp, #-8]
   11c74:	e5933004 	ldr	r3, [r3, #4]
   11c78:	e50b3008 	str	r3, [fp, #-8]
   11c7c:	ea000008 	b	11ca4 <merge_sort+0x164>
     }
    else {
      src->next = second;
   11c80:	e51b3008 	ldr	r3, [fp, #-8]
   11c84:	e51b2014 	ldr	r2, [fp, #-20]	; 0xffffffec
   11c88:	e5832004 	str	r2, [r3, #4]
      second = second->next;
   11c8c:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   11c90:	e5933004 	ldr	r3, [r3, #4]
   11c94:	e50b3014 	str	r3, [fp, #-20]	; 0xffffffec
      src = src->next;
   11c98:	e51b3008 	ldr	r3, [fp, #-8]
   11c9c:	e5933004 	ldr	r3, [r3, #4]
   11ca0:	e50b3008 	str	r3, [fp, #-8]
    }
  }
   
  src = head->next;

  while (first != NULL && second != NULL) {
   11ca4:	e51b3010 	ldr	r3, [fp, #-16]
   11ca8:	e3530000 	cmp	r3, #0
   11cac:	0a000002 	beq	11cbc <merge_sort+0x17c>
   11cb0:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   11cb4:	e3530000 	cmp	r3, #0
   11cb8:	1affffe0 	bne	11c40 <merge_sort+0x100>
      second = second->next;
      src = src->next;
    }
  }

  while (first != NULL) {
   11cbc:	ea000008 	b	11ce4 <merge_sort+0x1a4>
    src->next = first;
   11cc0:	e51b3008 	ldr	r3, [fp, #-8]
   11cc4:	e51b2010 	ldr	r2, [fp, #-16]
   11cc8:	e5832004 	str	r2, [r3, #4]
    first = first->next;
   11ccc:	e51b3010 	ldr	r3, [fp, #-16]
   11cd0:	e5933004 	ldr	r3, [r3, #4]
   11cd4:	e50b3010 	str	r3, [fp, #-16]
    src = src->next;
   11cd8:	e51b3008 	ldr	r3, [fp, #-8]
   11cdc:	e5933004 	ldr	r3, [r3, #4]
   11ce0:	e50b3008 	str	r3, [fp, #-8]
      second = second->next;
      src = src->next;
    }
  }

  while (first != NULL) {
   11ce4:	e51b3010 	ldr	r3, [fp, #-16]
   11ce8:	e3530000 	cmp	r3, #0
   11cec:	1afffff3 	bne	11cc0 <merge_sort+0x180>
    src->next = first;
    first = first->next;
    src = src->next;
  }

  while (second != NULL) {
   11cf0:	ea000008 	b	11d18 <merge_sort+0x1d8>
    src->next = second;
   11cf4:	e51b3008 	ldr	r3, [fp, #-8]
   11cf8:	e51b2014 	ldr	r2, [fp, #-20]	; 0xffffffec
   11cfc:	e5832004 	str	r2, [r3, #4]
    second = second->next;
   11d00:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   11d04:	e5933004 	ldr	r3, [r3, #4]
   11d08:	e50b3014 	str	r3, [fp, #-20]	; 0xffffffec
    src = src->next;
   11d0c:	e51b3008 	ldr	r3, [fp, #-8]
   11d10:	e5933004 	ldr	r3, [r3, #4]
   11d14:	e50b3008 	str	r3, [fp, #-8]
    src->next = first;
    first = first->next;
    src = src->next;
  }

  while (second != NULL) {
   11d18:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   11d1c:	e3530000 	cmp	r3, #0
   11d20:	1afffff3 	bne	11cf4 <merge_sort+0x1b4>
    src->next = second;
    second = second->next;
    src = src->next;
  }  

  return head;
   11d24:	e51b300c 	ldr	r3, [fp, #-12]
}
   11d28:	e1a00003 	mov	r0, r3
   11d2c:	e24bd004 	sub	sp, fp, #4
   11d30:	e8bd8800 	pop	{fp, pc}

00011d34 <main>:

int main(void)
{
   11d34:	e92d4800 	push	{fp, lr}
   11d38:	e28db004 	add	fp, sp, #4
   11d3c:	e24dd010 	sub	sp, sp, #16
  insert_tail(& node,6);       display(& node);  // 3 4 6
  clean_list(& node);
  #endif 

#if 1
  node = NULL;
   11d40:	e3a03000 	mov	r3, #0
   11d44:	e50b3008 	str	r3, [fp, #-8]
  printf("\n################# reverse  ################\n");
   11d48:	e59f00f8 	ldr	r0, [pc, #248]	; 11e48 <main+0x114>
   11d4c:	ebfff9a5 	bl	103e8 <puts@plt>
  insert_tail(& node, 61); insert_tail(& node, 62); insert_tail(& node, 63); insert_tail(& node, 64); insert_tail(& node, 65);
   11d50:	e24b3008 	sub	r3, fp, #8
   11d54:	e3a0103d 	mov	r1, #61	; 0x3d
   11d58:	e1a00003 	mov	r0, r3
   11d5c:	ebfffd12 	bl	111ac <insert_tail>
   11d60:	e24b3008 	sub	r3, fp, #8
   11d64:	e3a0103e 	mov	r1, #62	; 0x3e
   11d68:	e1a00003 	mov	r0, r3
   11d6c:	ebfffd0e 	bl	111ac <insert_tail>
   11d70:	e24b3008 	sub	r3, fp, #8
   11d74:	e3a0103f 	mov	r1, #63	; 0x3f
   11d78:	e1a00003 	mov	r0, r3
   11d7c:	ebfffd0a 	bl	111ac <insert_tail>
   11d80:	e24b3008 	sub	r3, fp, #8
   11d84:	e3a01040 	mov	r1, #64	; 0x40
   11d88:	e1a00003 	mov	r0, r3
   11d8c:	ebfffd06 	bl	111ac <insert_tail>
   11d90:	e24b3008 	sub	r3, fp, #8
   11d94:	e3a01041 	mov	r1, #65	; 0x41
   11d98:	e1a00003 	mov	r0, r3
   11d9c:	ebfffd02 	bl	111ac <insert_tail>
  display(& node); //  61 62 63 64 65
   11da0:	e24b3008 	sub	r3, fp, #8
   11da4:	e1a00003 	mov	r0, r3
   11da8:	ebfffcae 	bl	11068 <display>
  cur = reverse_perfect_debug(node); // 单指针，需要返回值
  printf("cur=reverse_3(node) %p:%p:%p\n", cur, node, node->next);  display(& cur);  // 65 64 63 62 61
                                                                    display(& node); // 61
  #endif
  #if 1
  printf("%p:%p \n", node, *node);
   11dac:	e51b1008 	ldr	r1, [fp, #-8]
   11db0:	e51b3008 	ldr	r3, [fp, #-8]
   11db4:	e893000c 	ldm	r3, {r2, r3}
   11db8:	e59f008c 	ldr	r0, [pc, #140]	; 11e4c <main+0x118>
   11dbc:	ebfff986 	bl	103dc <printf@plt>
  printf("%p:%p:%p:%p:%p\n", node, node->next, node->next->next, node->next->next->next, node->next->next->next->next);
   11dc0:	e51b1008 	ldr	r1, [fp, #-8]
   11dc4:	e51b3008 	ldr	r3, [fp, #-8]
   11dc8:	e5930004 	ldr	r0, [r3, #4]
   11dcc:	e51b3008 	ldr	r3, [fp, #-8]
   11dd0:	e5933004 	ldr	r3, [r3, #4]
   11dd4:	e593c004 	ldr	ip, [r3, #4]
   11dd8:	e51b3008 	ldr	r3, [fp, #-8]
   11ddc:	e5933004 	ldr	r3, [r3, #4]
   11de0:	e5933004 	ldr	r3, [r3, #4]
   11de4:	e5933004 	ldr	r3, [r3, #4]
   11de8:	e51b2008 	ldr	r2, [fp, #-8]
   11dec:	e5922004 	ldr	r2, [r2, #4]
   11df0:	e5922004 	ldr	r2, [r2, #4]
   11df4:	e5922004 	ldr	r2, [r2, #4]
   11df8:	e5922004 	ldr	r2, [r2, #4]
   11dfc:	e58d2004 	str	r2, [sp, #4]
   11e00:	e58d3000 	str	r3, [sp]
   11e04:	e1a0300c 	mov	r3, ip
   11e08:	e1a02000 	mov	r2, r0
   11e0c:	e59f003c 	ldr	r0, [pc, #60]	; 11e50 <main+0x11c>
   11e10:	ebfff971 	bl	103dc <printf@plt>
  reverse_perfect_noreturn_debug(& node); // 双指针，不需要返回值
   11e14:	e24b3008 	sub	r3, fp, #8
   11e18:	e1a00003 	mov	r0, r3
   11e1c:	ebfffa45 	bl	10738 <reverse_perfect_noreturn_debug>
  display(& node); // 61
   11e20:	e24b3008 	sub	r3, fp, #8
   11e24:	e1a00003 	mov	r0, r3
   11e28:	ebfffc8e 	bl	11068 <display>
  #endif

  #if 0
  cur = reverse_2(node);  display(& cur);  display(& node);
  #endif
  clean_list(& node);
   11e2c:	e24b3008 	sub	r3, fp, #8
   11e30:	e1a00003 	mov	r0, r3
   11e34:	ebfffc77 	bl	11018 <clean_list>
  clean_list(& first);  clean_list(& second);
  #endif
#endif


  return 0;
   11e38:	e3a03000 	mov	r3, #0
}
   11e3c:	e1a00003 	mov	r0, r3
   11e40:	e24bd004 	sub	sp, fp, #4
   11e44:	e8bd8800 	pop	{fp, pc}
   11e48:	00012398 	.word	0x00012398
   11e4c:	000123c8 	.word	0x000123c8
   11e50:	00011e70 	.word	0x00011e70

Disassembly of section .fini:

00011e54 <_fini>:
   11e54:	e1a0c00d 	mov	ip, sp
   11e58:	e92ddff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, ip, lr, pc}
   11e5c:	e24cb004 	sub	fp, ip, #4
   11e60:	e91baff0 	ldmdb	fp, {r4, r5, r6, r7, r8, r9, sl, fp, sp, pc}
